public void ToStringTest()
{
XmlDocument doc = NiniDoc();
AddSection(doc, "Pets");
AddKey(doc, "Pets", "cat", "Muffy");
AddKey(doc, "Pets", "dog", "Rover");
DotNetConfigSource source =
new DotNetConfigSource(DocumentToReader(doc));
string eol = Environment.NewLine;
string compare = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + eol
+ "<configuration>" + eol
+ " <configSections>" + eol
+ " <section name=\"Pets\" "
+ "type=\"System.Configuration.NameValueSectionHandler\" />" + eol
+ " </configSections>" + eol
+ " <Pets>" + eol
+ " <add key=\"cat\" value=\"Muffy\" />" + eol
+ " <add key=\"dog\" value=\"Rover\" />" + eol
+ " </Pets>" + eol
+ "</configuration>";
Assert.AreEqual(compare, source.ToString());
}
public void SetAndSave()
{
string filePath = "Test.xml";
XmlDocument doc = NiniDoc();
AddSection(doc, "NewSection");
AddKey(doc, "NewSection", "dog", "Rover");
AddKey(doc, "NewSection", "cat", "Muffy");
doc.Save(filePath);
DotNetConfigSource source = new DotNetConfigSource(filePath);
IConfig config = source.Configs["NewSection"];
Assert.AreEqual("Rover", config.Get("dog"));
Assert.AreEqual("Muffy", config.Get("cat"));
config.Set("dog", "Spots");
config.Set("cat", "Misha");
config.Set("DoesNotExist", "SomeValue");
Assert.AreEqual("Spots", config.Get("dog"));
Assert.AreEqual("Misha", config.Get("cat"));
Assert.AreEqual("SomeValue", config.Get("DoesNotExist"));
source.Save();
source = new DotNetConfigSource(filePath);
config = source.Configs["NewSection"];
Assert.AreEqual("Spots", config.Get("dog"));
Assert.AreEqual("Misha", config.Get("cat"));
Assert.AreEqual("SomeValue", config.Get("DoesNotExist"));
File.Delete(filePath);
}
public override void Start(string[] args)
{
IKernel k = NinjectFactory.getKernel <DynamicLoaderModule>();
BindableHost.Host = Host;
BindableWorld.World = World;
k.Bind <IHost>().To <BindableHost>().InSingletonScope();
k.Bind <IWorld>().To <BindableWorld>().InSingletonScope();
string configFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
if (!File.Exists(configFile))
{
throw new Exception("Unable to start MRM system. No config file found at '" + Path.GetFullPath(configFile) + "'.");
}
IConfig config = new DotNetConfigSource(configFile).Configs["Bootstrap"];
if (config == null)
{
throw new Exception("Unable to start MRM system. No 'Bootstrap' section found in config file '" + Path.GetFullPath(configFile) + "'.");
}
string queueLibrary = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, config.GetString(QUEUE + ASSEMBLY, typeof(AsynchQueueFactory).Assembly.Location));
string queueType = config.GetString(QUEUE + CLASS, typeof(AsynchQueueFactory).FullName);
k.Get <IDynamicLoaderModule>().BindDynamic(typeof(IAsynchQueueFactory), queueLibrary, queueType, true);
Start(k, config, configFile, Host.Object.GlobalID, true);
}
private static void FileAndSaveTest()
{
var source = new DotNetConfigSource(DotNetConfigSource.GetFullConfigPath());
var config = source.Configs["appSettings"];
config = source.Configs["Pets"];
AssertEquals("rover", config.Get("dog"));
AssertEquals("muffy", config.Get("cat"));
Assert(config.Get("not here") == null, "Should not be present");
config.Set("dog", "Spots");
config.Set("cat", "Misha");
AssertEquals("Spots", config.Get("dog"));
AssertEquals("Misha", config.Get("cat"));
// Cannot perform save yet until technical issues resolved
/*
* string fileName = "DotNetConfigSourceTests.exe.config";
* source.Save ();
*
* source = new DotNetConfigSource ();
* config = source.Configs["Pets"];
* AssertEquals ("Spots", config.Get ("dog"));
* AssertEquals ("Misha", config.Get ("cat"));
*
* File.Delete (fileName);
*/
}
public void NoConfigSectionsNode()
{
string filePath = "AppSettings.xml";
// Create an XML document with no configSections node
XmlDocument doc = new XmlDocument();
doc.LoadXml("<configuration></configuration>");
XmlNode node = doc.CreateElement("appSettings");
doc.DocumentElement.AppendChild(node);
AddKey(doc, "appSettings", "Test", "Hello");
doc.Save(filePath);
DotNetConfigSource source = new DotNetConfigSource(filePath);
IConfig config = source.Configs["appSettings"];
Assert.AreEqual("Hello", config.GetString("Test"));
File.Delete(filePath);
}
public void LoadReader()
{
XmlDocument doc = NiniDoc();
AddSection(doc, "Pets");
AddKey(doc, "Pets", "cat", "muffy");
AddKey(doc, "Pets", "dog", "rover");
AddKey(doc, "Pets", "bird", "tweety");
DotNetConfigSource source =
new DotNetConfigSource(DocumentToReader(doc));
IConfig config = source.Configs["Pets"];
Assert.AreEqual(3, config.GetKeys().Length);
Assert.AreEqual("rover", config.Get("dog"));
config.Set("dog", "new name");
config.Remove("bird");
source.Load(DocumentToReader(doc));
config = source.Configs["Pets"];
Assert.AreEqual(3, config.GetKeys().Length);
Assert.AreEqual("rover", config.Get("dog"));
}
public void SaveToStream()
{
string filePath = "SaveToStream.ini";
FileStream stream = new FileStream(filePath, FileMode.Create);
// Create a new document and save to stream
DotNetConfigSource source = new DotNetConfigSource();
IConfig config = source.AddConfig("Pets");
config.Set("dog", "rover");
config.Set("cat", "muffy");
source.Save(stream);
stream.Close();
DotNetConfigSource newSource = new DotNetConfigSource(filePath);
config = newSource.Configs["Pets"];
Assert.IsNotNull(config);
Assert.AreEqual(2, config.GetKeys().Length);
Assert.AreEqual("rover", config.GetString("dog"));
Assert.AreEqual("muffy", config.GetString("cat"));
stream.Close();
File.Delete(filePath);
}
public void EmptyConstructor()
{
string filePath = "EmptyConstructor.xml";
DotNetConfigSource source = new DotNetConfigSource();
IConfig config = source.AddConfig("Pets");
config.Set("cat", "Muffy");
config.Set("dog", "Rover");
config.Set("bird", "Tweety");
source.Save(filePath);
Assert.AreEqual(3, config.GetKeys().Length);
Assert.AreEqual("Muffy", config.Get("cat"));
Assert.AreEqual("Rover", config.Get("dog"));
Assert.AreEqual("Tweety", config.Get("bird"));
source = new DotNetConfigSource(filePath);
config = source.Configs["Pets"];
Assert.AreEqual(3, config.GetKeys().Length);
Assert.AreEqual("Muffy", config.Get("cat"));
Assert.AreEqual("Rover", config.Get("dog"));
Assert.AreEqual("Tweety", config.Get("bird"));
File.Delete(filePath);
}
/*
* public static Form StartGui(IConfig config, ViewerProxy form, Func<Form> createForm) {
* if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA) {
* Form f = createForm();
* StartProxyClient(config, form, f);
* f.ShowDialog();
* return f;
* } else {
* object createLock = new object();
* Form f = null;
* bool started = false;
* Thread t = new Thread(() => {
* f = createForm();
* lock (createLock)
* MonitorChanged.PulseAll(createLock);
* started = true;
* StartProxyClient(config, form, f);
* f.ShowDialog();
* });
* t.SetApartmentState(ApartmentState.STA);
* t.Begin();
* if (!started)
* lock (createLock)
* MonitorChanged.Wait(createLock);
* return f;
* }
* }
*
* private static void StartProxyClient(IConfig config, ViewerProxy form, Form f) {
* f.VisibleChanged += (source, args) => {
* if (!f.Visible)
* return;
* bool autostartProxy = Get(config, "AutoStartProxy", false);
* bool autostartClient = Get(config, "AutoStartClient", false);
*
* if (autostartProxy || autostartClient)
* while (!form.StartProxy())
* form.ProxyConfig.ProxyPort++;
* if (autostartClient)
* form.StartClient();
* };
* }
*/
public static IConfigSource AddFile(IConfigSource config, string file)
{
if (File.Exists(file) && Path.GetExtension(file).ToUpper().Equals(".CONFIG"))
{
try {
DotNetConfigSource dotnet = new DotNetConfigSource(file);
//config.Merge(dotnet);
dotnet.Merge(config);
return(dotnet);
} catch (Exception e) {
Logger.Warn("Unable to load app configuration file " + file + "'." + e.Message + ".\n" + e.StackTrace);
}
}
else if (File.Exists(file) && Path.GetExtension(file).ToUpper().Equals(".INI"))
{
try {
IniDocument doc = new IniDocument(file, IniFileType.WindowsStyle);
IniConfigSource ini = new IniConfigSource(doc);
//config.Merge(ini);
ini.Merge(config);
return(ini);
} catch (Exception e) {
Logger.Warn("Unable to load ini configuration file " + file + "'." + e.Message + ".\n" + e.StackTrace);
}
}
return(config);
}
public void SaveNewSection()
{
string filePath = "Test.xml";
XmlDocument doc = NiniDoc();
AddSection(doc, "NewSection");
AddKey(doc, "NewSection", "dog", "Rover");
AddKey(doc, "NewSection", "cat", "Muffy");
doc.Save(filePath);
DotNetConfigSource source = new DotNetConfigSource(filePath);
IConfig config = source.AddConfig("test");
Assert.IsNotNull(source.Configs["test"]);
source.Save();
source = new DotNetConfigSource(filePath);
config = source.Configs["NewSection"];
Assert.AreEqual("Rover", config.Get("dog"));
Assert.AreEqual("Muffy", config.Get("cat"));
Assert.IsNotNull(source.Configs["test"]);
File.Delete(filePath);
}
/// <summary>
/// Creates a new config file.
/// </summary>
private void CreateNewFile()
{
string type = null;;
if (IsArg("set-type"))
{
type = GetArg("set-type").ToLower();
}
else
{
ThrowError("You must supply a type (--set-type)");
}
switch (type)
{
case "ini":
IniConfigSource iniSource = new IniConfigSource();
iniSource.Save(configPath);
break;
case "xml":
XmlConfigSource xmlSource = new XmlConfigSource();
xmlSource.Save(configPath);
break;
case "config":
DotNetConfigSource dotnetSource = new DotNetConfigSource();
dotnetSource.Save(configPath);
break;
default:
ThrowError("Unknown type");
break;
}
}
public void ReplaceText()
{
XmlDocument doc = NiniDoc();
AddSection(doc, "Test");
AddKey(doc, "Test", "author", "Brent");
AddKey(doc, "Test", "domain", "${protocol}://nini.sf.net/");
AddKey(doc, "Test", "apache", "Apache implements ${protocol}");
AddKey(doc, "Test", "developer", "author of Nini: ${author} !");
AddKey(doc, "Test", "love", "We love the ${protocol} protocol");
AddKey(doc, "Test", "combination", "${author} likes ${protocol}");
AddKey(doc, "Test", "fact", "fact: ${apache}");
AddKey(doc, "Test", "protocol", "http");
DotNetConfigSource source =
new DotNetConfigSource(DocumentToReader(doc));
source.ReplaceKeyValues();
IConfig config = source.Configs["Test"];
Assert.AreEqual("http", config.Get("protocol"));
Assert.AreEqual("fact: Apache implements http", config.Get("fact"));
Assert.AreEqual("http://nini.sf.net/", config.Get("domain"));
Assert.AreEqual("Apache implements http", config.Get("apache"));
Assert.AreEqual("We love the http protocol", config.Get("love"));
Assert.AreEqual("author of Nini: Brent !", config.Get("developer"));
Assert.AreEqual("Brent likes http", config.Get("combination"));
}
public void SaveToWriter()
{
string newPath = "TestNew.xml";
XmlDocument doc = NiniDoc();
AddSection(doc, "Pets");
AddKey(doc, "Pets", "cat", "Muffy");
AddKey(doc, "Pets", "dog", "Rover");
DotNetConfigSource source =
new DotNetConfigSource(DocumentToReader(doc));
IConfig config = source.Configs["Pets"];
Assert.AreEqual("Rover", config.Get("dog"));
Assert.AreEqual("Muffy", config.Get("cat"));
StreamWriter textWriter = new StreamWriter(newPath);
source.Save(textWriter);
textWriter.Close(); // save to disk
source = new DotNetConfigSource(newPath);
config = source.Configs["Pets"];
Assert.AreEqual("Rover", config.Get("dog"));
Assert.AreEqual("Muffy", config.Get("cat"));
File.Delete(newPath);
}
public void SaveToNewPath()
{
string filePath = "Test.xml";
string newPath = "TestNew.xml";
XmlDocument doc = NiniDoc();
AddSection(doc, "Pets");
AddKey(doc, "Pets", "cat", "Muffy");
AddKey(doc, "Pets", "dog", "Rover");
doc.Save(filePath);
DotNetConfigSource source = new DotNetConfigSource(filePath);
IConfig config = source.Configs["Pets"];
Assert.AreEqual("Rover", config.Get("dog"));
Assert.AreEqual("Muffy", config.Get("cat"));
source.Save(newPath);
source = new DotNetConfigSource(newPath);
config = source.Configs["Pets"];
Assert.AreEqual("Rover", config.Get("dog"));
Assert.AreEqual("Muffy", config.Get("cat"));
File.Delete(filePath);
File.Delete(newPath);
}
public void MergeAndSave()
{
string xmlFileName = "NiniConfig.xml";
XmlDocument doc = NiniDoc();
AddSection(doc, "Pets");
AddKey(doc, "Pets", "cat", "Muffy");
AddKey(doc, "Pets", "dog", "Rover");
AddKey(doc, "Pets", "bird", "Tweety");
doc.Save(xmlFileName);
StringWriter writer = new StringWriter();
writer.WriteLine("[Pets]");
writer.WriteLine("cat = Becky"); // overwrite
writer.WriteLine("lizard = Saurus"); // new
writer.WriteLine("[People]");
writer.WriteLine(" woman = Jane");
writer.WriteLine(" man = John");
IniConfigSource iniSource = new IniConfigSource
(new StringReader(writer.ToString()));
DotNetConfigSource xmlSource = new DotNetConfigSource(xmlFileName);
xmlSource.Merge(iniSource);
IConfig config = xmlSource.Configs["Pets"];
Assert.AreEqual(4, config.GetKeys().Length);
Assert.AreEqual("Becky", config.Get("cat"));
Assert.AreEqual("Rover", config.Get("dog"));
Assert.AreEqual("Saurus", config.Get("lizard"));
config = xmlSource.Configs["People"];
Assert.AreEqual(2, config.GetKeys().Length);
Assert.AreEqual("Jane", config.Get("woman"));
Assert.AreEqual("John", config.Get("man"));
config.Set("woman", "Tara");
config.Set("man", "Quentin");
xmlSource.Save();
xmlSource = new DotNetConfigSource(xmlFileName);
config = xmlSource.Configs["Pets"];
Assert.AreEqual(4, config.GetKeys().Length);
Assert.AreEqual("Becky", config.Get("cat"));
Assert.AreEqual("Rover", config.Get("dog"));
Assert.AreEqual("Saurus", config.Get("lizard"));
config = xmlSource.Configs["People"];
Assert.AreEqual(2, config.GetKeys().Length);
Assert.AreEqual("Tara", config.Get("woman"));
Assert.AreEqual("Quentin", config.Get("man"));
File.Delete(xmlFileName);
}
public WinterNationals2011PairsScorer()
{
InitializeComponent();
m_configParameters = new DotNetConfigSource(DotNetConfigSource.GetFullConfigPath());
getFieldName("GoogleSiteName");
Globals.m_rootDirectory = Directory.GetCurrentDirectory();
loadEventPageMapping();
}
/// <summary>Prevents a default instance of the <see cref="MudEngineAttributes"/> class from being created.</summary>
private MudEngineAttributes()
{
string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
path = Path.Combine(path, "mud.config");
this.config = new DotNetConfigSource(path);
this.GetConfigSettings();
}
private static string GetMudName()
{
string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
path = Path.Combine(path, "mud.config");
var config = new DotNetConfigSource(path);
string mudName = config.Configs["EngineAttributes"].GetString("name");
return(mudName);
}
static AppConfig()
{
var userConfigFile = Path.Combine(ApplicationData, "user.config");
if (!File.Exists(userConfigFile))
{
File.Copy(DotNetConfigSource.GetFullConfigPath(), userConfigFile);
}
configSource = new DotNetConfigSource(userConfigFile);
appSettings = configSource.Configs ["appSettings"];
}
public void SetFolder(string folder)
{
DotNetConfigSource source = new DotNetConfigSource();
IConfig cfg = source.Configs["Config"];
if (cfg == null)
{
cfg = source.Configs.Add("Config");
}
cfg.Set("ConfigFolder", folder);
source.Save(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile);
}
private void applicationList_SelectedIndexChanged(object sender, EventArgs e)
{
string file = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "../" + applicationList.SelectedItem + ".exe.config"));
IConfigSource src = new DotNetConfigSource(file);
string folder = "Configs/Test";
if (src.Configs["Config"] != null)
{
folder = src.Configs["Config"].Get("ConfigFolder", folder).Substring(8).TrimEnd('/', '\\');
}
folderList.SelectedItem = folderList.Items.OfType <string>().FirstOrDefault(f => f == folder);
}
private static void FileTest()
{
var source = new DotNetConfigSource(DotNetConfigSource.GetFullConfigPath());
var config = source.Configs["appSettings"];
Assert(config != null, "IConfig is null");
AssertEquals("My App", config.Get("App Name"));
config = source.Configs["Pets"];
AssertEquals("rover", config.Get("dog"));
AssertEquals("muffy", config.Get("cat"));
Assert(config.Get("not here") == null, "Should not be present");
}
private static void WebTest()
{
var sections = new string[] { "appSettings", "Pets" };
var source = new DotNetConfigSource(sections);
var config = source.Configs["appSettings"];
Assert(config != null, "IConfig is null");
AssertEquals("My App", config.Get("App Name"));
config = source.Configs["Pets"];
AssertEquals("rover", config.Get("dog"));
AssertEquals("muffy", config.Get("cat"));
Assert(config.Get("not here") == null, "Should not be present");
}
private void bindButton_Click(object sender, EventArgs e)
{
string configFile = Path.Combine("..", applicationList.SelectedItem + ".exe.config");
string configPath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, configFile));
DotNetConfigSource source = new DotNetConfigSource(configPath);
IConfig cfg = source.Configs["Config"];
if (cfg == null)
{
cfg = source.Configs.Add("Config");
}
cfg.Set("ConfigFolder", "Configs/" + folderList.SelectedItem);
source.Save(configPath);
}
public void Reload()
{
string filePath = "ReloadDot.xml";
DotNetConfigSource source = new DotNetConfigSource();
IConfig petConfig = source.AddConfig("Pets");
petConfig.Set("cat", "Muffy");
petConfig.Set("dog", "Rover");
IConfig weatherConfig = source.AddConfig("Weather");
weatherConfig.Set("skies", "cloudy");
weatherConfig.Set("precipitation", "rain");
source.Save(filePath);
Assert.AreEqual(2, petConfig.GetKeys().Length);
Assert.AreEqual("Muffy", petConfig.Get("cat"));
Assert.AreEqual(2, source.Configs.Count);
DotNetConfigSource newSource = new DotNetConfigSource(filePath);
IConfig compareConfig = newSource.Configs["Pets"];
Assert.AreEqual(2, compareConfig.GetKeys().Length);
Assert.AreEqual("Muffy", compareConfig.Get("cat"));
Assert.IsTrue(compareConfig == newSource.Configs["Pets"],
"References before are not equal");
// Set the new values to source
source.Configs["Pets"].Set("cat", "Misha");
source.Configs["Pets"].Set("lizard", "Lizzy");
source.Configs["Pets"].Set("hampster", "Surly");
source.Configs["Pets"].Remove("dog");
source.Configs.Remove(weatherConfig);
source.Save(); // saves new value
// Reload the new source and check for changes
newSource.Reload();
Assert.IsTrue(compareConfig == newSource.Configs["Pets"],
"References after are not equal");
Assert.AreEqual(1, newSource.Configs.Count);
Assert.AreEqual(3, newSource.Configs["Pets"].GetKeys().Length);
Assert.AreEqual("Lizzy", newSource.Configs["Pets"].Get("lizard"));
Assert.AreEqual("Misha", newSource.Configs["Pets"].Get("cat"));
Assert.IsNull(newSource.Configs["Pets"].Get("dog"));
File.Delete(filePath);
}
public void GetConfig()
{
XmlDocument doc = NiniDoc();
AddSection(doc, "Pets");
AddKey(doc, "Pets", "cat", "muffy");
AddKey(doc, "Pets", "dog", "rover");
AddKey(doc, "Pets", "bird", "tweety");
DotNetConfigSource source =
new DotNetConfigSource(DocumentToReader(doc));
IConfig config = source.Configs["Pets"];
Assert.AreEqual("Pets", config.Name);
Assert.AreEqual(3, config.GetKeys().Length);
Assert.AreEqual(source, config.ConfigSource);
}
public void GetString()
{
XmlDocument doc = NiniDoc();
AddSection(doc, "Pets");
AddKey(doc, "Pets", "cat", "muffy");
AddKey(doc, "Pets", "dog", "rover");
AddKey(doc, "Pets", "bird", "tweety");
DotNetConfigSource source =
new DotNetConfigSource(DocumentToReader(doc));
IConfig config = source.Configs["Pets"];
Assert.AreEqual("muffy", config.Get("cat"));
Assert.AreEqual("rover", config.Get("dog"));
Assert.AreEqual("muffy", config.GetString("cat"));
Assert.AreEqual("rover", config.GetString("dog"));
Assert.AreEqual("my default", config.Get("Not Here", "my default"));
Assert.IsNull(config.Get("Not Here 2"));
}
static Config()
{
AppConfigRoot = new Nini.Config.DotNetConfigSource(DotNetConfigSource.GetFullConfigPath());
AppSettings = AppConfigRoot.Configs["appSettings"];
bool hasExtraConfig = false;
IConfigSource extraConfigRoot = null;
if (File.Exists(ExtraConfigFile))
{
hasExtraConfig = true;
ExtraConfigRoot = new Nini.Config.XmlConfigSource(ExtraConfigFile);
extraConfigRoot = ExtraConfigRoot;
}
if (File.Exists(PrivateExtraConfigFile))
{
hasExtraConfig = true;
PrivateExtraConfigRoot = new Nini.Config.XmlConfigSource(PrivateExtraConfigFile);
if (extraConfigRoot != null)
{
extraConfigRoot.Merge(PrivateExtraConfigRoot);
}
else
{
extraConfigRoot = PrivateExtraConfigRoot;
}
}
if (hasExtraConfig)
{
ExtraConfig = extraConfigRoot.Configs["Settings"];
RconServerAddress = ExtraConfig.GetString("RconServerAddress");
RconServerPort = ExtraConfig.GetInt("RconServerPort");
RconServerPassword = ExtraConfig.GetString("RconServerPassword");
}
else
{
throw new ApplicationException("Can't find config file: " + ExtraConfigFile);
}
}
/// <summary>
/// Loads a sourc from file.
/// </summary>
private IConfigSource LoadSource(string path)
{
IConfigSource result = null;
string extension = null;
if (IsArg("set-type"))
{
extension = "." + GetArg("set-type").ToLower();
}
else
{
FileInfo info = new FileInfo(path);
extension = info.Extension;
}
switch (extension)
{
case ".ini":
result = new IniConfigSource(path);
break;
case ".config":
result = new DotNetConfigSource(path);
break;
case ".xml":
result = new XmlConfigSource(path);
break;
default:
ThrowError("Unknown config file type");
break;
}
if (verbose)
{
PrintLine("Loaded config: " + result.GetType().Name);
}
return(result);
}
public void GetInt()
{
XmlDocument doc = NiniDoc();
AddSection(doc, "Pets");
AddKey(doc, "Pets", "value 1", "49588");
DotNetConfigSource source =
new DotNetConfigSource(DocumentToReader(doc));
IConfig config = source.Configs["Pets"];
Assert.AreEqual(49588, config.GetInt("value 1"));
Assert.AreEqual(12345, config.GetInt("Not Here", 12345));
try
{
config.GetInt("Not Here Also");
Assert.Fail();
}
catch
{
}
}
