public void Configuration_SlfConfigurationSection_ValidFactoryTest()
{
Assert.IsNotNull(_configuration);
var section = _configuration.GetSection("slf4net-valid-factory") as SlfConfigurationSection;
Assert.IsNotNull(section);
Assert.IsNotNull(section.Factory);
Assert.IsFalse(string.IsNullOrEmpty(section.Factory.Type));
Assert.AreEqual("slf4net.Factories.SimpleLoggerFactory, slf4net.Simple", section.Factory.Type);
Assert.IsTrue(string.IsNullOrEmpty(section.Factory.FactoryData));
string expected = "test.factory.type";
string actual;
section.Factory.Type = expected;
actual = section.Factory.Type;
Assert.AreEqual(expected, actual);
FactoryConfigurationElement expectedFactory = new FactoryConfigurationElement();
FactoryConfigurationElement actualFactory;
actualFactory = section.Factory;
Assert.AreNotEqual(expectedFactory, actualFactory);
section.Factory = expectedFactory;
actualFactory = section.Factory;
Assert.AreEqual(expectedFactory, actualFactory);
}
public static IEntityContextFactory FromConfiguration(string configurationName)
{
var result = new DefaultEntityContextFactory();
FactoryConfigurationElement factoryConfiguration = RdefNetConfigurationSection.Default.Factories[configurationName];
if (factoryConfiguration != null)
{
result.WithMappings(
builder =>
{
foreach (MappingAssemblyConfigurationElement mappingAssemblyConfiguration in factoryConfiguration.MappingAssemblies)
{
var mappingAssembly = Assembly.Load(new AssemblyName(mappingAssemblyConfiguration.Name));
builder = builder.FromAssembly(mappingAssembly);
}
});
foreach (QIriConfigurationElement qIri in factoryConfiguration.QIris)
{
result.WithQIri(qIri.Prefix, new Iri(qIri.Iri));
}
}
return(result);
}
public void FactoryDataTest()
{
FactoryConfigurationElement target = new FactoryConfigurationElement(); // TODO: Initialize to an appropriate value
string expected = string.Empty; // TODO: Initialize to an appropriate value
string actual;
target.FactoryData = expected;
actual = target.FactoryData;
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void CreateFactoryInstanceTest()
{
AppConfigFactoryResolver_Accessor target = new AppConfigFactoryResolver_Accessor(); // TODO: Initialize to an appropriate value
FactoryConfigurationElement factoryConfiguration = null; // TODO: Initialize to an appropriate value
ILogFactory expected = null; // TODO: Initialize to an appropriate value
ILogFactory actual;
actual = target.CreateFactoryInstance(factoryConfiguration);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
/// <summary> Creates a factory based on a given configuration. If the factory provides invalid information, an error is logged through the internal log, and a <see cref="NullLogFactory" /> returned. </summary>
/// <param name="factoryConfiguration"> The configuration that provides type information for the <see cref="ILogFactory" /> that is being created. </param>
/// <returns> Factory instance. </returns>
private ILogFactory CreateFactoryInstance(FactoryConfigurationElement factoryConfiguration)
{
ILogFactory factory = ActivatorHelper.Instantiate <ILogFactory>(factoryConfiguration.Type, DiagnosticLog);
//if the factory is configurable, invoke its Init method
IConfigurableLogFactory cf = factory as IConfigurableLogFactory;
if (cf != null)
{
cf.Init(factoryConfiguration.FactoryData);
}
if (factory == null)
{
factory = NullLogFactory.Instance;
}
return(factory);
}
/// <summary>
/// Creates a factory based on a given configuration.
/// If the factory provides invalid information, an error is logged through
/// the internal logger, and a <see cref="NOPLoggerFactory"/> returned.
/// </summary>
/// <param name="factoryConfiguration">The configuration that provides type
/// information for the <see cref="ILoggerFactory"/> that is being created.</param>
/// <returns>Factory instance.</returns>
private ILoggerFactory CreateFactoryInstance(FactoryConfigurationElement factoryConfiguration)
{
ILoggerFactory factory = ActivatorUtils.Instantiate <ILoggerFactory>(factoryConfiguration.Type);
IConfigurableLoggerFactory cf = factory as IConfigurableLoggerFactory;
// If the factory is configurable, invoke its Init method
if (cf != null)
{
cf.Init(factoryConfiguration.FactoryData);
}
else
{
if (!string.IsNullOrEmpty(factoryConfiguration.FactoryData))
{
throw new ConfigurationErrorsException("Factory " + factoryConfiguration.Type + " does not implement IConfigurableLoggerFactory.");
}
}
return(factory);
}
public void FactoryConfigurationElementConstructorTest()
{
FactoryConfigurationElement target = new FactoryConfigurationElement();
Assert.Inconclusive("TODO: Implement code to verify target");
}
