public static void SetupSerializers()
{
//
ConfigFilePath = Application.dataPath + @"\Binds";
defaultBindsSerializer = new ConfigSerializer(ConfigFilePath + @"\DefaultBindings.txt");
keyBindsSerializer = new ConfigSerializer(ConfigFilePath + @"\KeyBindings.txt");
}
public void ShouldReturnCorrectConfig()
{
// Arrange
var testConfig = new TestConfig();
// System under Test
var configSerializer = new ConfigSerializer();
// Act
configSerializer.SetDeserializedConfigs(XDocument.Parse(CONFIG_XML), new IConfigSection[] { testConfig });
// Assert
Assert.AreEqual("6fa5a650-25f3-4c86-a515-37e3163a54e9", testConfig.TestVar1);
}
public void ShouldReturnCorrectXml()
{
// Arrange
var testConfig = new TestConfig { TestVar1 = "6fa5a650-25f3-4c86-a515-37e3163a54e9" };
// System under Test
var configSerializer = new ConfigSerializer();
// Act
var xmlDocument = configSerializer.GetSerializedConfigs(new IConfigSection[] { testConfig });
// Assert
Assert.AreEqual(CONFIG_XML.Replace(" ", ""), xmlDocument.ToString().Replace("\r\n", "").Replace(" ", ""));
}
private void Write()
{
ConfigSerializer serializer = new ConfigSerializer();
ConfigManager.Instance.SetSerializer(serializer);
ConfigManager.Instance.ReloadConfigReaderModule(new XmlConfigReaderModule(PathManager.Instance.ExternalXmlConfigFolder, readXmlThread));
using (BinWriter o = new BinWriter(PlatformManager.Instance.OpenWrite(PathManager.Instance.ExternalBinaryConfig), Encoding.UTF8))
{
ConfigManager.Instance.LoadAllConfig();
if (serializer.Validate())
{
serializer.WriteToBinary(o);
}
}
PlatformManager.Instance.ClearDirectory(PathManager.Instance.ExternalXmlExampleFolder);
new ConfigExampleBuilder().WriteExampleConfig(serializer, PathManager.Instance.ExternalXmlExampleFolder);
}
public void Init(string workingDirectory)
{
var configFilePath = this.configFileLocator.GetConfigFilePath(workingDirectory);
var currentConfiguration = this.configFileLocator.ReadConfig(workingDirectory);
var config = this.configInitWizard.Run(currentConfiguration, workingDirectory);
if (config == null || configFilePath == null)
{
return;
}
using var stream = this.fileSystem.OpenWrite(configFilePath);
using var writer = new StreamWriter(stream);
this.log.Info("Saving config file");
ConfigSerializer.Write(config, writer);
stream.Flush();
}
public void Should_WriteSample_Multiline_String_Values()
{
// Given
var builder = new StringBuilder();
// When
using (var writer = new StringWriter(builder))
{
ConfigSerializer.WriteSample(writer);
}
var text = builder.ToString();
// Then
var expectedText = string.Format("# footer-content: >-{0}# You can download this release from{0}#{0}# [chocolatey](https://chocolatey.org/packages/chocolateyGUI/{{milestone}})", Environment.NewLine);
Assert.That(text, Contains.Substring(expectedText));
}
public void Should_Write_Default_Boolean_Values()
{
// Given
var config = new Config();
config.Create.IncludeFooter = false; // Just to be sure it is a false value
// When
var builder = new StringBuilder();
using (var writer = new StringWriter(builder))
{
ConfigSerializer.Write(config, writer);
}
// Then
Assert.That(builder.ToString(), Contains.Substring("include-footer: false"));
}
public void Load()
{
ConfigSerializer.LoadConfig(this, FilePath);
if (TwitchChannel.Length > 0)
{
TwitchChannel = TwitchChannel.ToLower().Replace(" ", "");
}
//else {
//TwitchChannel = TwitchUsername;
//}
if (BackgroundPadding < 0)
{
BackgroundPadding = 0;
}
if (MaxMessages < 1)
{
MaxMessages = 1;
}
}
protected UnityConfigurationSection SerializeAndLoadConfig(string filename, Action <ContainerElement> containerInitializer)
{
var serializer = new ConfigSerializer(filename);
var section = new UnityConfigurationSection();
section.SectionExtensions.Add(new SectionExtensionElement()
{
TypeName = typeof(InterceptionConfigurationExtension).AssemblyQualifiedName
});
var container = new ContainerElement();
section.Containers.Add(container);
containerInitializer(container);
serializer.Save("unity", section);
return((UnityConfigurationSection)serializer.Load().GetSection("unity"));
}
private static string GetOverrideConfigHash(Config overrideConfig)
{
if (overrideConfig == null)
{
return(string.Empty);
}
// Doesn't depend on command line representation and
// includes possible changes in default values of Config per se.
var stringBuilder = new StringBuilder();
using (var stream = new StringWriter(stringBuilder))
{
ConfigSerializer.Write(overrideConfig, stream);
stream.Flush();
}
var configContent = stringBuilder.ToString();
return(GetHash(configContent));
}
public void Should_Read_Label_Aliases()
{
// Given
var text = Resources.Default_Configuration_Yaml;
using (var stringReader = new StringReader(text))
{
// When
var config = ConfigSerializer.Read(stringReader);
// Then
Assert.AreEqual(2, config.LabelAliases.Count);
Assert.AreEqual("Bug", config.LabelAliases[0].Name);
Assert.AreEqual("Foo", config.LabelAliases[0].Header);
Assert.AreEqual("Bar", config.LabelAliases[0].Plural);
Assert.AreEqual("Improvement", config.LabelAliases[1].Name);
Assert.AreEqual("Baz", config.LabelAliases[1].Header);
Assert.AreEqual("Qux", config.LabelAliases[1].Plural);
}
}
public void Test_Serialize_SingleFieldType()
{
ExampleSingleFieldConfig configInstance = new ExampleSingleFieldConfig
{
firstField = new ExampleSingleFieldConfig.SingleFieldType1 {
secondField = new ExampleSingleFieldConfig.SingleFieldType2 {
a = 1, b = 2
}
}
};
const string expectedResult = @"
- a = 1
- b = 2
";
IEnumerable <string> lines = new ConfigSerializer(
new ConfigOptions {
keyFormatOption = EFormatOption.QuoteValue,
valueFormatOption = EFormatOption.QuoteValue
}).Serialize(configInstance);
Assert.AreEqual(expectedResult.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries), lines.ToArray());
}
public Config(string filePath)
{
FilePath = filePath;
if (!Directory.Exists(Path.GetDirectoryName(FilePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(FilePath));
}
if (File.Exists(FilePath))
{
Load();
var text = File.ReadAllText(FilePath);
if (!text.Contains("fitToCanvas") && Path.GetFileName(FilePath) == "cameraplus.cfg")
{
fitToCanvas = true;
}
if (text.Contains("rotx"))
{
var oldRotConfig = new OldRotConfig();
ConfigSerializer.LoadConfig(oldRotConfig, FilePath);
var euler = new Quaternion(oldRotConfig.rotx, oldRotConfig.roty, oldRotConfig.rotz, oldRotConfig.rotw).eulerAngles;
angx = euler.x;
angy = euler.y;
angz = euler.z;
}
}
Save();
_configWatcher = new FileSystemWatcher(Path.GetDirectoryName(FilePath))
{
NotifyFilter = NotifyFilters.LastWrite,
Filter = Path.GetFileName(FilePath),
EnableRaisingEvents = true
};
_configWatcher.Changed += ConfigWatcherOnChanged;
}
public RootConfig(string filePath)
{
FilePath = filePath;
if (!Directory.Exists(Path.GetDirectoryName(FilePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(FilePath));
}
if (File.Exists(FilePath))
{
ConfigSerializer.LoadConfig(this, FilePath);
}
PluginConfig.Instance.ProfileSceneChange = ProfileSceneChange;
PluginConfig.Instance.MenuProfile = MenuProfile;
PluginConfig.Instance.GameProfile = GameProfile;
PluginConfig.Instance.RotateProfile = RotateProfile;
PluginConfig.Instance.MultiplayerProfile = MultiplayerProfile;
PluginConfig.Instance.ProfileLoadCopyMethod = ProfileLoadCopyMethod;
PluginConfig.Instance.CameraQuadLayer = CameraQuadLayer;
PluginConfig.Instance.ScreenFillBlack = ScreenFillBlack;
}
public virtual ActionResult UploadPhoto(string name, long id, HttpPostedFileBase file)
{
var al = Album.GetCountChange(id, 1);
if (al == null)
{
return(HttpNotFound("album not found"));
}
var p = new Photo {
Title = name, AlbumId = id, AddTime = DateTime.Now, UserId = WebUser.UserId
};
var f = new ImageUpload(file,
WebContext,
ConfigSerializer.Load <List <string> >("AllowImageExt")
, p.AddTime,
ConfigSerializer.Load <List <ThumbnailPair> >("ThumbnailSize")
);
f.Upload();
p.Summary = f.Ext;
Photo.Add(p);
return(RedirectToAction("details", new{ id }));
}
public override IEnumerable <string> Serialize(ConfigSerializer serializer, FieldInfo fieldInfo, SerializationInfo serializationInfo, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
IEnumerable <string> dataLines;
keyFormatOption = GetKeyFormatOption(keyFormatOption);
valueFormatOption = GetValueFormatOption(valueFormatOption);
if (serializationInfo.eDataType.IsSingleValueType())
{
string declarationString = ConfigSerializer.SerializeValueAssignmentDeclaration(name ?? fieldInfo.Name, currentIndentation + indentation, currentObjectDepth, keyFormatOption);
string dataString = ConfigSerializer.SerializeSingleValueType(serializationInfo, valueFormatOption);
dataLines = new[] { declarationString + dataString };
}
else
{
string declarationString = ConfigSerializer.SerializeObjectAssignmentDeclaration(name ?? fieldInfo.Name, currentIndentation + indentation, currentObjectDepth, keyFormatOption);
dataLines = new[] { declarationString }
.Concat(serializer.SerializeMultiValueType(serializationInfo, currentIndentation + indentation, currentObjectDepth + 1, keyFormatOption, valueFormatOption));
}
return(Enumerable.Repeat("", emptyLinesAbove)
.Concat(comments.Select(comment => new string('\t', currentIndentation + indentation) + SpecialCharacters.singleLineComment + " " + comment))
.Concat(dataLines));
}
public Config(string filePath)
{
FilePath = filePath;
if (File.Exists(FilePath))
{
Load();
var text = File.ReadAllText(FilePath);
if (text.Contains("rotx"))
{
var oldRotConfig = new OldRotConfig();
ConfigSerializer.LoadConfig(oldRotConfig, FilePath);
var euler = new Quaternion(oldRotConfig.rotx, oldRotConfig.roty, oldRotConfig.rotz,
oldRotConfig.rotw)
.eulerAngles;
angx = euler.x;
angy = euler.y;
angz = euler.z;
Save();
}
}
else
{
Save();
}
_configWatcher = new FileSystemWatcher(Environment.CurrentDirectory)
{
NotifyFilter = NotifyFilters.LastWrite,
Filter = "cameraplus.cfg",
EnableRaisingEvents = true
};
_configWatcher.Changed += ConfigWatcherOnChanged;
}
private void CoreUI_FormClosing(object sender, FormClosingEventArgs e)
{
Globals.AttackOn = false;
Globals.AttackMode = false;
Globals.Terminate = true;
if (RoomsPanel.Rooms.Count > 0)
{
RegistryUtil.Save();
IniWriter.Save();
ConfigSerializer.WriteFile("config.xml", Settings);
}
// clean up notifyicon
if (mNotifyIcon != null)
{
mNotifyIcon.Visible = false;
mNotifyIcon.Dispose();
mNotifyIcon = null;
}
Application.Exit();
Process.GetCurrentProcess().Kill();
}
/// <summary>
/// Loads a config from a file.
/// If an instance is provided, the config will be loaded to that instance
/// otherwise a new instance is created
/// </summary>
/// <param name="pathToFile">absolute path to the config file. '/' will be replaced with the DirectorySeparatorChar</param>
/// <param name="instance">optional - instance of the existing config</param>
/// <param name="configOptions">use this to configure the de/serializer</param>
/// <typeparam name="TConfigType">type of the config to load</typeparam>
/// <returns>instance of the loaded config</returns>
public static TConfigType LoadConfigFile <TConfigType>(string pathToFile, [CanBeNull] TConfigType instance, ConfigOptions configOptions = null)
{
pathToFile = pathToFile.Replace('/', Path.DirectorySeparatorChar);
if (!File.Exists(pathToFile))
{
if (instance == null)
{
instance = (TConfigType)Activator.CreateInstance(typeof(TConfigType));
}
IEnumerable <string> lines = new ConfigSerializer(configOptions).Serialize(instance);
using (StreamWriter writer = new StreamWriter(pathToFile, false)) {
foreach (string line in lines)
{
writer.WriteLine(line);
}
}
return(instance);
}
try {
using (StreamReader reader = File.OpenText(pathToFile)) {
List <string> lines = new List <string>();
{
string line;
while ((line = reader.ReadLine()) != null)
{
lines.Add(line);
}
}
ConfigDeserializer <TConfigType> deserializer = new ConfigDeserializer <TConfigType>(DeserializerUtils.Tokenize(lines).ToList(), configOptions);
return(instance == null?deserializer.Deserialize() : deserializer.Deserialize(instance));
}
} catch (Exception e) {
Debug.LogError("Failed to load config at path: '" + pathToFile + "', caught exception: " + e);
return(default);
public void Save()
{
_saving = true;
ConfigSerializer.SaveConfig(this, FilePath);
_saving = false;
}
public void Load()
{
ConfigSerializer.LoadConfig(this, FilePath);
}
public abstract IEnumerable <string> Serialize(ConfigSerializer serializer, FieldInfo fieldInfo, SerializationInfo serializationInfo, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption);
public static void SetupSerializers()
{
ConfigFilePath = @"D:\TempDelete\Assets\Binds";
defaultBindsSerializer = new ConfigSerializer(ConfigFilePath + @"\DefaultBindings.txt");
keyBindsSerializer = new ConfigSerializer(ConfigFilePath + @"\KeyBindings.txt");
}
public void Load()
{
ConfigSerializer.LoadConfig(this, FilePath);
CompileChargeCostString();
}
private void ExportOnClick(object sender, RoutedEventArgs e)
{
_control.Config.Text = ConfigSerializer.ToJson(_config);
}
public void Load()
{
ConfigSerializer.LoadConfig(this, FilePath);
CorrectConfigSettings();
}
static int Main(string[] argv)
{
bool help = false;
bool version = false;
bool once = false;
StartClient startClient = StartClient.No;
var config = new TypeCobolConfiguration();
config.CommandLine = string.Join(" ", argv);
var pipename = "TypeCobol.Server";
var p = TypeCobolOptionSet.GetCommonTypeCobolOptions(config);
//Add custom options for CLI
p.Add(string.Format("USAGE\n {0} [OPTIONS]... [PIPENAME]\n VERSION:\n {1} \n DESCRIPTION: \n Run the TypeCObol parser server", PROGNAME, PROGVERSION));
p.Add("k|startServer:",
"Start the server if not already started, and executes commandline.\n" + "By default the server is started in window mode\n" + "'{hidden}' hide the window.",
v =>
{
if ("hidden".Equals(v, StringComparison.InvariantCultureIgnoreCase))
{
startClient = StartClient.HiddenWindow;
}
else
{
startClient = StartClient.NormalWindow;
}
});
p.Add("1|once", "Parse one set of files and exit. If present, this option does NOT launch the server.", v => once = (v != null));
p.Add("h|help", "Output a usage message and exit.", v => help = (v != null));
p.Add("V|version", "Output the version number of " + PROGNAME + " and exit.", v => version = (v != null));
//Add DefaultCopies to running session
var folder = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName);
config.CopyFolders.Add(folder + @"\DefaultCopies\");
try {
List <string> args;
try {
args = p.Parse(argv);
} catch (OptionException ex) {
return(exit(ReturnCode.FatalError, ex.Message));
}
if (help)
{
p.WriteOptionDescriptions(Console.Out);
return(0);
}
if (version)
{
Console.WriteLine(PROGVERSION);
return(0);
}
if (config.Telemetry)
{
AnalyticsWrapper.Telemetry.DisableTelemetry = false; //If telemetry arg is passed enable telemetry
}
if (config.OutputFiles.Count == 0 && config.ExecToStep >= ExecutionStep.Generate)
{
config.ExecToStep = ExecutionStep.SemanticCheck; //If there is no given output file, we can't run generation, fallback to SemanticCheck
}
if (config.OutputFiles.Count > 0 && config.InputFiles.Count != config.OutputFiles.Count)
{
return(exit(ReturnCode.OutputFileError, "The number of output files must be equal to the number of input files."));
}
if (args.Count > 0)
{
pipename = args[0];
}
//"startClient" will be true when "-K" is passed as an argument in command line.
if (startClient != StartClient.No && once)
{
pipename = "TypeCobol.Server";
using (NamedPipeClientStream namedPipeClient = new NamedPipeClientStream(pipename))
{
try {
namedPipeClient.Connect(100);
} catch (TimeoutException tEx) {
System.Diagnostics.Process process = new System.Diagnostics.Process();
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
if (startClient == StartClient.NormalWindow)
{
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal;
}
else
{
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
startInfo.FileName = "cmd.exe";
startInfo.Arguments = @"/c " + folder + Path.DirectorySeparatorChar + "TypeCobol.CLI.exe";
process.StartInfo = startInfo;
process.Start();
namedPipeClient.Connect(1000);
}
namedPipeClient.WriteByte(68);
ConfigSerializer configSerializer = new ConfigSerializer();
var configBytes = configSerializer.Serialize(config);
namedPipeClient.Write(configBytes, 0, configBytes.Length);
//Wait for the response "job is done"
var returnCode = namedPipeClient.ReadByte(); //Get running server ReturnCode
return(exit((ReturnCode)returnCode, ""));
}
}
//option -1
else if (once)
{
var returnCode = CLI.runOnce(config);
if (returnCode != ReturnCode.Success)
{
return(exit(returnCode, "Operation failled"));
}
}
else
{
runServer(pipename);
}
}
catch (Exception e) {
AnalyticsWrapper.Telemetry.TrackException(e);
return(exit(ReturnCode.FatalError, e.Message));
}
return(exit((int)ReturnCode.Success, "Success"));
}
protected override void OnAttached()
{
base.OnAttached();
AssociatedObject.EditValue = ConfigSerializer.GetConfig().KeyGesture;
AssociatedObject.PreviewKeyDown += OnPreviewKeyDown;
}
public ChatConfig()
{
Instance = this;
_configWatcher = new FileSystemWatcher();
Task.Run(() =>
{
while (!Directory.Exists(Path.GetDirectoryName(FilePath)))
{
Thread.Sleep(100);
}
Plugin.Log("FilePath exists! Continuing initialization!");
string oldFilePath = Path.Combine(Environment.CurrentDirectory, "UserData", "EnhancedTwitchChat.ini");
string newerFilePath = Path.Combine(Globals.DataPath, "EnhancedTwitchChat.ini");
if (File.Exists(newerFilePath))
{
// Append the data to the blacklist, if any blacklist info exists, then dispose of the old config file.
AppendToBlacklist(newerFilePath);
if (!File.Exists(FilePath))
{
File.Move(newerFilePath, FilePath);
}
else
{
File.Delete(newerFilePath);
}
}
else if (File.Exists(oldFilePath))
{
// Append the data to the blacklist, if any blacklist info exists, then dispose of the old config file.
AppendToBlacklist(oldFilePath);
if (!File.Exists(FilePath))
{
File.Move(oldFilePath, FilePath);
}
else
{
File.Delete(oldFilePath);
}
}
if (File.Exists(FilePath))
{
Load();
var text = File.ReadAllText(FilePath);
if (text.Contains("TwitchUsername="******"{Plugin.ModuleName.Replace(" ", "")}.ini";
_configWatcher.EnableRaisingEvents = true;
_configWatcher.Changed += ConfigWatcherOnChanged;
});
}
public void WriteXml_NoFile_NoError()
{
ConfigSerializer.ReadXml(_testFilePath, new TestObject());
}
public void Test_Serialize_SpecialCharOptions()
{
const string normalString = "asdf";
string specialCharacterString = "" + SpecialCharacters.objectDepth + SpecialCharacters.valueAssignment + SpecialCharacters.objectAssignment
+ SpecialCharacters.nullChar + SpecialCharacters.stringChar + SpecialCharacters.escapeChar;
ExampleNullableConfig exampleNullableConfig = new ExampleNullableConfig {
stringValue = normalString,
stringValue2 = specialCharacterString,
stringList = new List <string> {
normalString, specialCharacterString
},
subClassList = new List <ExampleNullableConfig.ExampleNullableSubClass> {
new ExampleNullableConfig.ExampleNullableSubClass {
a = normalString
},
new ExampleNullableConfig.ExampleNullableSubClass {
a = specialCharacterString
}
},
stringDict = new Dictionary <string, string> {
{ normalString, normalString },
{ specialCharacterString, specialCharacterString }
},
subClassDict = new Dictionary <string, ExampleNullableConfig.ExampleNullableSubClass> {
{ normalString, new ExampleNullableConfig.ExampleNullableSubClass {
a = normalString
} },
{ specialCharacterString, new ExampleNullableConfig.ExampleNullableSubClass {
a = specialCharacterString
} }
}
};
string[] ExpectedLines(EFormatOption keyOpt, EFormatOption valueOpt)
{
return(new[] {
$"- {SpecialCharacters.FormatStringValue("intValue", keyOpt)} = {SpecialCharacters.FormatStringValue("1", valueOpt)}",
$"- {SpecialCharacters.FormatStringValue("stringValue", keyOpt)} = {SpecialCharacters.FormatStringValue(normalString, valueOpt)}",
$"- {SpecialCharacters.FormatStringValue("stringValue2", keyOpt)} = {SpecialCharacters.FormatStringValue(specialCharacterString, valueOpt)}",
$"- {SpecialCharacters.FormatStringValue("intList", keyOpt)} :",
$"-- {SpecialCharacters.FormatStringValue("1", valueOpt)}",
$"-- {SpecialCharacters.FormatStringValue("1", valueOpt)}",
$"- {SpecialCharacters.FormatStringValue("stringList", keyOpt)} :",
$"-- {SpecialCharacters.FormatStringValue(normalString, valueOpt)}",
$"-- {SpecialCharacters.FormatStringValue(specialCharacterString, valueOpt)}",
$"- {SpecialCharacters.FormatStringValue("subClassList", keyOpt)} :",
"-- :",
$"--- {SpecialCharacters.FormatStringValue("a", keyOpt)} = {SpecialCharacters.FormatStringValue(normalString, valueOpt)}",
$"--- {SpecialCharacters.FormatStringValue("b", keyOpt)} = {SpecialCharacters.FormatStringValue("1", valueOpt)}",
"-- :",
$"--- {SpecialCharacters.FormatStringValue("a", keyOpt)} = {SpecialCharacters.FormatStringValue(specialCharacterString, valueOpt)}",
$"--- {SpecialCharacters.FormatStringValue("b", keyOpt)} = {SpecialCharacters.FormatStringValue("1", valueOpt)}",
$"- {SpecialCharacters.FormatStringValue("intDict", keyOpt)} :",
$"-- {SpecialCharacters.FormatStringValue("1", keyOpt)} = {SpecialCharacters.FormatStringValue("1", valueOpt)}",
$"-- {SpecialCharacters.FormatStringValue("2", keyOpt)} = {SpecialCharacters.FormatStringValue("2", valueOpt)}",
$"- {SpecialCharacters.FormatStringValue("stringDict", keyOpt)} :",
$"-- {SpecialCharacters.FormatStringValue(normalString, keyOpt)} = {SpecialCharacters.FormatStringValue(normalString, valueOpt)}",
$"-- {SpecialCharacters.FormatStringValue(specialCharacterString, keyOpt)} = {SpecialCharacters.FormatStringValue(specialCharacterString, valueOpt)}",
$"- {SpecialCharacters.FormatStringValue("subClassDict", keyOpt)} :",
$"-- {SpecialCharacters.FormatStringValue(normalString, keyOpt)} :",
$"--- {SpecialCharacters.FormatStringValue("a", keyOpt)} = {SpecialCharacters.FormatStringValue(normalString, valueOpt)}",
$"--- {SpecialCharacters.FormatStringValue("b", keyOpt)} = {SpecialCharacters.FormatStringValue("1", valueOpt)}",
$"-- {SpecialCharacters.FormatStringValue(specialCharacterString, keyOpt)} :",
$"--- {SpecialCharacters.FormatStringValue("a", keyOpt)} = {SpecialCharacters.FormatStringValue(specialCharacterString, valueOpt)}",
$"--- {SpecialCharacters.FormatStringValue("b", keyOpt)} = {SpecialCharacters.FormatStringValue("1", valueOpt)}",
});
}
foreach (EFormatOption keyOpt in (EFormatOption[])Enum.GetValues(typeof(EFormatOption)))
{
foreach (EFormatOption valueOpt in (EFormatOption[])Enum.GetValues(typeof(EFormatOption)))
{
string[] resultLines = new ConfigSerializer(
new ConfigOptions {
keyFormatOption = keyOpt,
valueFormatOption = valueOpt
}).Serialize(exampleNullableConfig).ToArray();
Assert.AreEqual(ExpectedLines(keyOpt, valueOpt), resultLines, "keyOpt: {0}, valueOpt: {1}", keyOpt, valueOpt);
}
}
}
public void Test_Serialize_Implicitly()
{
/* Scenarios to check:
* - explicit by default, no override
* + implicit by default, override both types
* - explicit by default, override outer type
* + implicit by default, override inner type
* - explicit by default, override inner type
* + implicit by default, override outer type
* - explicit by default, override both types
* + implicit by default, no override
*/
IEnumerable <string> GetLines(bool outerIsExplicit, bool innerIsExplicit)
{
if (!outerIsExplicit)
{
yield return("- a = 3");
}
yield return("- b = 4");
if (!outerIsExplicit)
{
yield return("- subClass :");
if (!innerIsExplicit)
{
yield return("-- a = 5");
}
yield return("-- b = 6");
}
}
ImplicitConfig configToSerialize = new ImplicitConfig(3, 4, new ImplicitConfig.SubClass(5, 6));
void RunTest(bool outerIsExplicit, bool innerIsExplicit, ConfigOptions configOptions)
{
ConfigSerializer configDeserializer = new ConfigSerializer(configOptions);
string[] resultLines = configDeserializer.Serialize(configToSerialize).ToArray();
string[] expectedLines = GetLines(outerIsExplicit, innerIsExplicit).ToArray();
bool areEqual = resultLines.Length == expectedLines.Length && !resultLines.Except(expectedLines).Any();
Assert.True(areEqual, "Expected lines: '{0}', Received Lines: '{1}'", string.Join("', '", expectedLines), string.Join("', '", resultLines));
}
Type outerType = typeof(ImplicitConfig);
Type innerType = typeof(ImplicitConfig.SubClass);
RunTest(true, true, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Explicit
});
RunTest(true, true, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Implicit, explicitTypes = new List <Type> {
outerType, innerType
}
});
RunTest(false, true, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Explicit, implicitTypes = new List <Type> {
outerType
}
});
RunTest(false, true, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Implicit, explicitTypes = new List <Type> {
innerType
}
});
RunTest(true, false, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Explicit, implicitTypes = new List <Type> {
innerType
}
});
RunTest(true, false, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Implicit, explicitTypes = new List <Type> {
outerType
}
});
RunTest(false, false, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Explicit, implicitTypes = new List <Type> {
outerType, innerType
}
});
RunTest(false, false, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Implicit
});
}
public CoreUI()
{
InitializeComponent();
// silver vs2008 toolstrip look
TanColorTable colorTable = new TanColorTable();
colorTable.UseSystemColors = true;
toolStrip.Renderer = new ToolStripProfessionalRenderer(colorTable);
// fill panels
AccountsPanel = new AccountsPanel(this);
AccountsPanel.Dock = DockStyle.Fill;
splitLeftRight.Panel1.Controls.Add(AccountsPanel);
LogPanel = new LogPanel();
LogPanel.Dock = DockStyle.Fill;
splitTopBottom.Panel1.Controls.Add(LogPanel);
mAttackPanel = new AttackPanel(this);
mAttackPanel.Dock = DockStyle.Fill;
tabs.TabPages[TABINDEX_ATTACK].Controls.Add(mAttackPanel);
/*
* MainPanel = new MainPanel(this);
* MainPanel.Dock = DockStyle.Fill;
* splitLeftRight2.Panel1.Controls.Add(MainPanel);
*/
mFiltersPanel = new FiltersPanel(this);
mFiltersPanel.Dock = DockStyle.Fill;
tabs.TabPages[TABINDEX_FILTERS].Controls.Add(mFiltersPanel);
RoomsPanel = new RoomsPanel(this);
RoomsPanel.Dock = DockStyle.Fill;
tabs.TabPages[TABINDEX_ROOMS].Controls.Add(RoomsPanel);
MobsPanel = new MobsPanel(this);
MobsPanel.Dock = DockStyle.Fill;
tabs.TabPages[TABINDEX_MOBS].Controls.Add(MobsPanel);
RaidsPanel = new RaidsPanel(this);
RaidsPanel.Dock = DockStyle.Fill;
tabs.TabPages[TABINDEX_RAIDS].Controls.Add(RaidsPanel);
SpawnsPanel = new SpawnsPanel(this);
SpawnsPanel.Dock = DockStyle.Fill;
tabs.TabPages[TABINDEX_SPAWNS].Controls.Add(SpawnsPanel);
mTrainPanel = new TrainPanel(this);
mTrainPanel.Dock = DockStyle.Fill;
tabs.TabPages[TABINDEX_TRAINER].Controls.Add(mTrainPanel);
mTalkPanel = new TalkPanel(this);
mTalkPanel.Dock = DockStyle.Fill;
tabs.TabPages[TABINDEX_TALK].Controls.Add(mTalkPanel);
ChatPanel = new ChatUI(this);
ChatPanel.Dock = DockStyle.Fill;
tabs.TabPages[TABINDEX_CHAT].Controls.Add(ChatPanel);
Instance = this;
Settings = ConfigSerializer.ReadFile("config.xml");
this.Text = "Typpo's DC Tool - [www.typpo.us] - v" + Version.Id;
foreach (string s in Server.NamesList)
{
ListViewGroup grp = new ListViewGroup(s);
AccountsPanel.Groups.Add(grp);
}
}
public void Test_SerializeNullValues()
{
ExampleNullableConfig exampleNullableConfig = new ExampleNullableConfig {
stringValue = null,
stringValue2 = "~",
stringList = new List <string> {
null, "~"
},
subClassList = new List <ExampleNullableConfig.ExampleNullableSubClass> {
new ExampleNullableConfig.ExampleNullableSubClass {
a = null
},
new ExampleNullableConfig.ExampleNullableSubClass {
a = "~"
}
},
stringDict = new Dictionary <string, string> {
{ "str1", null },
{ "~", "~" }
},
subClassDict = new Dictionary <string, ExampleNullableConfig.ExampleNullableSubClass> {
{ "str1", new ExampleNullableConfig.ExampleNullableSubClass {
a = null
} },
{ "~", new ExampleNullableConfig.ExampleNullableSubClass {
a = "~"
} }
}
};
const string expectedResult = @"
- intValue = 1
- stringValue = ~
- stringValue2 = ""~""
- intList :
-- 1
-- 1
- stringList :
-- ~
-- ""~""
- subClassList :
-- :
--- a = ~
--- b = 1
-- :
--- a = ""~""
--- b = 1
- intDict :
-- 1 = 1
-- 2 = 2
- stringDict :
-- str1 = ~
-- ""~"" = ""~""
- subClassDict :
-- str1 :
--- a = ~
--- b = 1
-- ""~"" :
--- a = ""~""
--- b = 1
";
IEnumerable <string> lines = new ConfigSerializer(
new ConfigOptions {
keyFormatOption = EFormatOption.QuoteValue,
valueFormatOption = EFormatOption.QuoteValue
}).Serialize(exampleNullableConfig);
Assert.AreEqual(expectedResult.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries), lines.ToArray());
}