private static void AddBlockSettingsPolicy(
AdmContentBuilder contentBuilder,
String sectionKey,
LoggingSettings configurationSection)
{
contentBuilder.StartPolicy(Resources.LoggingSettingsPolicyName, sectionKey);
{
contentBuilder.AddDropDownListPartForNamedElementCollection <TraceSourceData>(
Resources.LoggingSettingsDefaultCategoryPartName,
DefaultCategoryPropertyName,
configurationSection.TraceSources,
configurationSection.DefaultCategory,
false);
contentBuilder.AddCheckboxPart(Resources.LoggingSettingsLogWarningPartName,
LogWarningOnNoMatchPropertyName,
configurationSection.LogWarningWhenNoCategoriesMatch);
contentBuilder.AddCheckboxPart(Resources.LoggingSettingsEnableTracingPartName,
TracingEnabledPropertyName,
configurationSection.TracingEnabled);
contentBuilder.AddCheckboxPart(Resources.LoggingSettingsRevertImpersonationPartName,
RevertImpersonationPropertyName,
configurationSection.RevertImpersonation);
}
contentBuilder.EndPolicy();
}
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder,
CategoryFilterData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
contentBuilder.AddDropDownListPartForEnumeration <CategoryFilterMode>(Resources.CategoryFilterFilterModePartName,
CategoryFilterModePropertyName,
configurationObject.CategoryFilterMode);
contentBuilder.AddTextPart(Resources.CategoryFilterCategoriesPartName);
LoggingSettings configurationSection
= configurationSource.GetSection(LoggingSettings.SectionName) as LoggingSettings;
String logFilterCategoriesKeyName
= elementPolicyKeyName + @"\" + CategoryFiltersKeyName;
foreach (TraceSourceData category in configurationSection.TraceSources)
{
contentBuilder.AddCheckboxPart(category.Name,
logFilterCategoriesKeyName,
category.Name,
configurationObject.CategoryFilters.Contains(category.Name),
true,
false);
}
}
/// <summary>
/// Adds the ADM instructions that describe the policies that can be used to override the configuration
/// information represented by a configuration section.
/// </summary>
/// <param name="contentBuilder">The <see cref="AdmContentBuilder"/> to which the Adm instructions are to be appended.</param>
/// <param name="configurationSection">The configuration section instance.</param>
/// <param name="configurationSource">The configuration source from where to get additional configuration
/// information, if necessary.</param>
/// <param name="sectionKey">The root key for the section's policies.</param>
protected override void AddAdministrativeTemplateDirectives(
AdmContentBuilder contentBuilder,
LoggingSettings configurationSection,
IConfigurationSource configurationSource,
String sectionKey)
{
AddBlockSettingsPolicy(contentBuilder, sectionKey, configurationSection);
AddCategorySourcesPolicies(contentBuilder, sectionKey, configurationSection);
AddSpecialSourcesPolicies(contentBuilder, sectionKey, configurationSection);
AddElementsPolicies <LogFilterData>(contentBuilder,
configurationSection.LogFilters,
configurationSource,
sectionKey + @"\" + LogFiltersKeyName,
Resources.LogFiltersCategoryName);
AddElementsPolicies <FormatterData>(contentBuilder,
configurationSection.Formatters,
configurationSource,
sectionKey + @"\" + LogFormattersKeyName,
Resources.LogFormattersCategoryName);
AddElementsPolicies <TraceListenerData>(contentBuilder,
configurationSection.TraceListeners,
configurationSource,
sectionKey + @"\" + TraceListenersKeyName,
Resources.TraceListenersCategoryName);
}
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
OracleConnectionSettings configurationSection,
IConfigurationSource configurationSource,
String sectionKey)
{
contentBuilder.StartCategory(Resources.OracleConnectionsCategoryName);
{
foreach (OracleConnectionData data in configurationSection.OracleConnectionsData)
{
String connectionPolicyKey = sectionKey + @"\" + data.Name;
contentBuilder.StartPolicy(String.Format(CultureInfo.InvariantCulture,
Resources.OracleConnectionPolicyNameTemplate,
data.Name),
connectionPolicyKey);
{
contentBuilder.AddEditTextPart(Resources.OracleConnectionPackagesPartName,
PackagesPropertyName,
GenerateRulesString(data.Packages),
1024,
true);
}
contentBuilder.EndPolicy();
}
}
contentBuilder.EndCategory();
}
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder,
WmiTraceListenerData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
AddTraceOptionsPart(contentBuilder, configurationObject.TraceOutputOptions);
}
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
ConnectionStringsSection configurationSection,
IConfigurationSource configurationSource,
String sectionKey)
{
contentBuilder.StartCategory(Resources.ConnectionStringsCategoryName);
{
foreach (ConnectionStringSettings connectionString in configurationSection.ConnectionStrings)
{
contentBuilder.StartPolicy(String.Format(CultureInfo.InvariantCulture,
Resources.ConnectionStringPolicyNameTemplate,
connectionString.Name),
sectionKey + @"\" + connectionString.Name);
contentBuilder.AddEditTextPart(Resources.ConnectionStringConnectionStringPartName,
ConnectionStringPropertyName,
connectionString.ConnectionString,
500,
true);
contentBuilder.AddComboBoxPart(Resources.ConnectionStringProviderNamePartName,
ProviderNamePropertyName,
connectionString.ProviderName,
255,
true,
"System.Data.SqlClient",
"System.Data.OracleClient");
contentBuilder.EndPolicy();
}
}
contentBuilder.EndCategory();
}
protected override void AddAdministrativeTemplateDirectives(
AdmContentBuilder contentBuilder,
DatabaseSettings configurationSection,
IConfigurationSource configurationSource,
string sectionKey)
{
contentBuilder.StartPolicy(Resources.DatabaseSettingsPolicyName, sectionKey);
List <AdmDropDownListItem> dropDownListItemList = new List <AdmDropDownListItem>();
ConnectionStringsSection section = (ConnectionStringsSection)configurationSource.GetSection("connectionStrings");
if (section != null)
{
foreach (ConnectionStringSettings connectionString in (ConfigurationElementCollection)section.ConnectionStrings)
{
dropDownListItemList.Add(new AdmDropDownListItem(connectionString.Name, connectionString.Name));
}
}
contentBuilder.AddDropDownListPart(Resources.DatabaseSettingsDefaultDatabasePartName, "defaultDatabase", (IEnumerable <AdmDropDownListItem>)dropDownListItemList, configurationSection.DefaultDatabase);
contentBuilder.EndPolicy();
if (configurationSection.ProviderMappings.Count <= 0)
{
return;
}
contentBuilder.StartCategory(Resources.ProviderMappingsCategoryName);
foreach (DbProviderMapping providerMapping in configurationSection.ProviderMappings)
{
contentBuilder.StartPolicy(string.Format((IFormatProvider)CultureInfo.InvariantCulture, Resources.ProviderMappingPolicyNameTemplate, (object)providerMapping.Name), sectionKey + "\\providerMappings\\" + providerMapping.Name);
contentBuilder.AddComboBoxPart(Resources.ProviderMappingDatabaseTypePartName, "databaseType", providerMapping.DatabaseType.AssemblyQualifiedName, (int)byte.MaxValue, false, DatabaseSettingsManageabilityProvider.DatabaseTypeNames);
contentBuilder.EndPolicy();
}
contentBuilder.EndCategory();
}
/// <summary>
/// <para>This method supports the Enterprise Library Manageability Extensions infrastructure and is not intended to
/// be used directly from your code.</para>
/// Adds the ADM instructions that describe the policies that can be used to override the configuration
/// information for the Cryptography Application Block.
/// </summary>
/// <seealso cref="ConfigurationSectionManageabilityProvider.AddAdministrativeTemplateDirectives(AdmContentBuilder, ConfigurationSection, IConfigurationSource, String)"/>
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
CryptographySettings configurationSection,
IConfigurationSource configurationSource,
String sectionKey)
{
contentBuilder.StartPolicy(Resources.CryptographySettingsPolicyName, sectionKey);
{
contentBuilder.AddDropDownListPartForNamedElementCollection <HashProviderData>(Resources.CryptographySettingsDefaultHashProviderPartName,
DefaultHashProviderPropertyName,
configurationSection.HashProviders,
configurationSection.DefaultHashProviderName,
true);
contentBuilder.AddDropDownListPartForNamedElementCollection <SymmetricProviderData>(Resources.CryptographySettingsDefaultSymmetricCryptoProviderPartName,
DefaultSymmetricCryptoProviderPropertyName,
configurationSection.SymmetricCryptoProviders,
configurationSection.DefaultSymmetricCryptoProviderName,
true);
}
contentBuilder.EndPolicy();
AddElementsPolicies <HashProviderData>(contentBuilder,
configurationSection.HashProviders,
configurationSource,
sectionKey + @"\" + HashProvidersKeyName,
Resources.HashProvidersCategoryName);
AddElementsPolicies <SymmetricProviderData>(contentBuilder,
configurationSection.SymmetricCryptoProviders,
configurationSource,
sectionKey + @"\" + SymmetricCryptoProvidersKeyName,
Resources.SymmetricCryptoProvidersCategoryName);
}
private static void AddTraceSourcePolicy(TraceSourceData traceSourceData,
String traceSourceName,
String parentKey,
AdmContentBuilder contentBuilder,
LoggingSettings configurationSection)
{
String traceSourceKey = parentKey + @"\" + traceSourceName;
contentBuilder.StartPolicy(String.Format(CultureInfo.InvariantCulture,
Resources.TraceSourcePolicyNameTemplate,
traceSourceName),
traceSourceKey);
{
contentBuilder.AddDropDownListPartForEnumeration <SourceLevels>(Resources.TraceSourceDefaultLevelPartName,
SourceDefaultLevelPropertyName,
traceSourceData.DefaultLevel);
contentBuilder.AddTextPart(Resources.TraceSourceListenersPartName);
String traceSourceListenersKey = traceSourceKey + @"\" + SourceTraceListenersPropertyName;
foreach (TraceListenerData traceListener in configurationSection.TraceListeners)
{
contentBuilder.AddCheckboxPart(traceListener.Name,
traceSourceListenersKey,
traceListener.Name,
traceSourceData.TraceListeners.Contains(traceListener.Name),
true,
false);
}
}
contentBuilder.EndPolicy();
}
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
TestConfigurationSection configurationSection,
IConfigurationSource configurationSource,
string sectionKey)
{
throw new Exception("The method or operation is not implemented.");
}
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder,
FlatFileTraceListenerData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
contentBuilder.AddEditTextPart(Resources.FlatFileTraceListenerFileNamePartName,
FileNamePropertyName,
configurationObject.FileName,
255,
true);
contentBuilder.AddEditTextPart(Resources.FlatFileTraceListenerHeaderPartName,
HeaderPropertyName,
configurationObject.Header,
512,
false);
contentBuilder.AddEditTextPart(Resources.FlatFileTraceListenerFooterPartName,
FooterPropertyName,
configurationObject.Footer,
512,
false);
AddTraceOptionsPart(contentBuilder, configurationObject.TraceOutputOptions);
AddFormattersPart(contentBuilder, configurationObject.Formatter, configurationSource);
}
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder,
FaultContractExceptionHandlerData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
contentBuilder.AddTextPart(String.Format(CultureInfo.CurrentCulture,
Resources.HandlerPartNameTemplate,
configurationObject.Name));
contentBuilder.AddEditTextPart(Resources.FaultContractExceptionHandlerExceptionMessagePartName,
elementPolicyKeyName,
ExceptionMessagePropertyName,
configurationObject.ExceptionMessage,
512,
true);
contentBuilder.AddEditTextPart(Resources.FaultContractExceptionHandlerFaultContractTypePartName,
elementPolicyKeyName,
FaultContractTypePropertyName,
configurationObject.FaultContractType,
512,
true);
contentBuilder.AddEditTextPart(Resources.FaultContractExceptionHandlerAttributesPartName,
elementPolicyKeyName,
AttributesPropertyName,
GenerateAttributesString(configurationObject.Attributes),
1024,
false);
}
/// <summary>
/// Adds the ADM parts that represent the properties of
/// a specific instance of the configuration element type managed by the receiver.
/// </summary>
/// <param name="contentBuilder">The <see cref="AdmContentBuilder"/> to which the Adm instructions are to be appended.</param>
/// <param name="configurationObject">The configuration object instance.</param>
/// <param name="configurationSource">The configuration source from where to get additional configuration
/// information, if necessary.</param>
/// <param name="elementPolicyKeyName">The key for the element's policies.</param>
/// <remarks>
/// Subclasses that manage custom provider's configuration objects with additional properties may
/// override this method to add the corresponding parts.
/// </remarks>
/// <seealso cref="ConfigurationElementManageabilityProviderBase{T}.AddAdministrativeTemplateDirectives(AdmContentBuilder, T, IConfigurationSource, String)"/>
protected override void AddElementAdministrativeTemplateParts(
AdmContentBuilder contentBuilder,
T configurationObject,
IConfigurationSource configurationSource,
string elementPolicyKeyName)
{
base.AddElementAdministrativeTemplateParts(contentBuilder,
configurationObject,
configurationSource,
elementPolicyKeyName);
contentBuilder.AddEditTextPart(Resources.CustomTraceListenerInitializationPartName,
InitDataPropertyName,
configurationObject.InitData,
1024,
false);
contentBuilder.AddTextPart(Resources.TraceListenerTraceOptionsPartName);
var traceOptionsKey = elementPolicyKeyName + @"\" + TraceOutputOptionsPropertyName;
AddCheckboxPartsForFlagsEnumeration <TraceOptions>(contentBuilder, traceOptionsKey, configurationObject.TraceOutputOptions);
contentBuilder.AddDropDownListPartForEnumeration <SourceLevels>(Resources.TraceListenerFilterPartName,
FilterPropertyName,
configurationObject.Filter);
}
private static void AddSpecialSourcesPolicies(
AdmContentBuilder contentBuilder,
String sectionKey,
LoggingSettings configurationSection)
{
String specialTraceSourcesKey = sectionKey + @"\" + SpecialSourcesKeyName;
contentBuilder.StartCategory(Resources.SpecialSourcesCategoryName);
AddTraceSourcePolicy(configurationSection.SpecialTraceSources.AllEventsTraceSource,
SpecialSourcesAllEventsKeyName,
specialTraceSourcesKey,
contentBuilder,
configurationSection);
AddTraceSourcePolicy(configurationSection.SpecialTraceSources.NotProcessedTraceSource,
SpecialSourcesNotProcessedKeyName,
specialTraceSourcesKey,
contentBuilder,
configurationSection);
AddTraceSourcePolicy(configurationSection.SpecialTraceSources.ErrorsTraceSource,
SpecialSourcesErrorsKeyName,
specialTraceSourcesKey,
contentBuilder,
configurationSection);
contentBuilder.EndCategory();
}
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder,
FormattedEventLogTraceListenerData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
contentBuilder.AddEditTextPart(Resources.EventLogTraceListenerSourcePartName,
SourcePropertyName,
configurationObject.Source,
255,
true);
contentBuilder.AddEditTextPart(Resources.EventLogTraceListenerLogPartName,
LogPropertyName,
configurationObject.Log,
255,
false);
contentBuilder.AddEditTextPart(Resources.EventLogTraceListenerMachineNamePartName,
MachineNamePropertyName,
configurationObject.MachineName,
255,
false);
AddTraceOptionsPart(contentBuilder, configurationObject.TraceOutputOptions);
AddFormattersPart(contentBuilder, configurationObject.Formatter, configurationSource);
}
public void StartCategoryWithStartedPolicyThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("name", "key");
builder.StartCategory("subcategory");
}
public void GetContentWithStartedCategoriesThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.GetContent();
}
public void CreationFromFreshBuilderReturnsEmptyContent()
{
AdmContentBuilder builder = new AdmContentBuilder();
Assert.IsNotNull(builder.GetContent());
IEnumerator<AdmCategory> categoriesEnumerator = builder.GetContent().Categories.GetEnumerator();
Assert.IsFalse(categoriesEnumerator.MoveNext());
}
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
SymmetricStorageEncryptionProviderData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
// parts for encryption providers are part of their cache manager's policies
AddElementAdministrativeTemplateParts(contentBuilder, configurationObject, configurationSource, elementPolicyKeyName);
}
/// <summary>
/// Adds the ADM parts that represent the properties of
/// a specific instance of the configuration element type managed by the receiver.
/// </summary>
/// <param name="contentBuilder">The <see cref="AdmContentBuilder"/> to which the Adm instructions are to be appended.</param>
/// <param name="configurationObject">The configuration object instance.</param>
/// <param name="configurationSource">The configuration source from where to get additional configuration
/// information, if necessary.</param>
/// <param name="elementPolicyKeyName">The key for the element's policies.</param>
/// <remarks>
/// Subclasses managing objects that must not create a policy will likely need to include the elements' keys when creating the parts.
/// </remarks>
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder,
CacheStorageData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
// nothing to set for this part
contentBuilder.AddTextPart(Resources.NullBackingStoreNoSettingsPartName);
}
/// <summary>
/// <para>This method supports the Enterprise Library Manageability Extensions infrastructure and is not intended to
/// be used directly from your code.</para>
/// Adds the ADM instructions that describe the policies that can be used to override the configuration
/// information for the Caching Application Block.
/// </summary>
/// <seealso cref="ConfigurationSectionManageabilityProvider.AddAdministrativeTemplateDirectives(AdmContentBuilder, ConfigurationSection, IConfigurationSource, String)"/>
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
CacheManagerSettings configurationSection,
IConfigurationSource configurationSource,
String sectionKey)
{
AddAdministrativeTemplateDirectivesForSection(contentBuilder, configurationSection, sectionKey);
AddAdministrativeTemplateDirectivesForCacheManagers(contentBuilder, configurationSection, configurationSource, sectionKey);
}
/// <summary>
/// Adds the ADM parts that represent the properties of
/// a specific instance of the configuration element type managed by the receiver.
/// </summary>
/// <param name="contentBuilder">The <see cref="AdmContentBuilder"/> to which the Adm instructions are to be appended.</param>
/// <param name="configurationObject">The configuration object instance.</param>
/// <param name="configurationSource">The configuration source from where to get additional configuration
/// information, if necessary.</param>
/// <param name="elementPolicyKeyName">The key for the element's policies.</param>
/// <remarks>
/// Subclasses managing objects that must not create a policy will likely need to include the elements' keys when creating the parts.
/// </remarks>
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder,
LogEnabledFilterData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
contentBuilder.AddCheckboxPart(Resources.LogEnabledFilterEnabledPartName,
EnabledPropertyName,
configurationObject.Enabled);
}
/// <summary>
/// Adds the ADM parts that represent the properties of
/// a specific instance of the configuration element type managed by the receiver.
/// </summary>
/// <param name="contentBuilder">The <see cref="AdmContentBuilder"/> to which the Adm instructions are to be appended.</param>
/// <param name="configurationObject">The configuration object instance.</param>
/// <param name="configurationSource">The configuration source from where to get additional configuration
/// information, if necessary.</param>
/// <param name="elementPolicyKeyName">The key for the element's policies.</param>
/// <remarks>
/// Subclasses managing objects that must not create a policy will likely need to include the elements' keys when creating the parts.
/// </remarks>
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder,
HashAlgorithmProviderData configurationObject,
IConfigurationSource configurationSource,
string elementPolicyKeyName)
{
contentBuilder.AddCheckboxPart(Resources.HashAlgorithmProviderSaltEnabledPartName,
SaltEnabledPropertyName,
configurationObject.SaltEnabled);
}
/// <summary>
/// Adds the ADM parts that represent the properties of
/// a specific instance of the configuration element type managed by the receiver.
/// </summary>
/// <param name="contentBuilder">The <see cref="AdmContentBuilder"/> to which the Adm instructions are to be appended.</param>
/// <param name="configurationObject">The configuration object instance.</param>
/// <param name="configurationSource">The configuration source from where to get additional configuration
/// information, if necessary.</param>
/// <param name="elementPolicyKeyName">The key for the element's policies.</param>
/// <remarks>
/// Subclasses managing objects that must not create a policy will likely need to include the elements' keys when creating the parts.
/// </remarks>
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder,
DpapiSymmetricCryptoProviderData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
contentBuilder.AddDropDownListPartForEnumeration(Resources.DpapiSymmetricProviderScopePartName,
ScopePropertyName,
configurationObject.Scope);
}
internal new void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
ConfigurationElement configurationObject,
IConfigurationSource configurationSource,
string parentKey)
{
base.AddAdministrativeTemplateDirectives(contentBuilder,
configurationObject,
configurationSource,
parentKey);
}
/// <summary>
/// Adds the ADM instructions that describe the policies that can be used to override the properties of
/// a specific instance of the configuration element type managed by the receiver.
/// </summary>
/// <param name="contentBuilder">The <see cref="AdmContentBuilder"/> to which the Adm instructions are to be appended.</param>
/// <param name="configurationObject">The configuration object instance.</param>
/// <param name="configurationSource">The configuration source from where to get additional configuration
/// information, if necessary.</param>
/// <param name="parentKey">The key path for which the generated instructions' keys must be subKeys of.</param>
/// <remarks>
/// Class <see cref="ConfigurationElementManageabilityProviderBase{T}"/> provides a default implementation for this method that
/// calls the strongly-typed
/// <see cref="ConfigurationElementManageabilityProviderBase{T}.AddAdministrativeTemplateDirectives(AdmContentBuilder, T, IConfigurationSource, String)"/>
/// method.
/// </remarks>
public sealed override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
ConfigurationElement configurationObject,
IConfigurationSource configurationSource,
string parentKey)
{
T data = (T)configurationObject;
String elementPolicyKeyName = parentKey + @"\" + data.Name;
AddAdministrativeTemplateDirectives(contentBuilder, data, configurationSource, elementPolicyKeyName);
}
/// <summary>
/// Adds the part to edit the policy overrides for the trace options of a trace listener to the content
/// built by the <paramref name="contentBuilder"/>.
/// </summary>
/// <param name="contentBuilder">The builder for the content where the part will be added.</param>
/// <param name="parentKey"></param>
/// <param name="traceOutputOptions">The default value for the part.</param>
protected internal static void AddTraceOptionsPart(AdmContentBuilder contentBuilder,
string parentKey,
TraceOptions traceOutputOptions)
{
contentBuilder.AddTextPart(Resources.TraceListenerTraceOptionsPartName);
var traceOptionsKey = parentKey + @"\" + TraceOutputOptionsPropertyName;
AddCheckboxPartsForFlagsEnumeration <TraceOptions>(contentBuilder, traceOptionsKey, traceOutputOptions);
}
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
IsolatedStorageCacheStorageData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
AddElementAdministrativeTemplateParts(contentBuilder,
configurationObject,
configurationSource,
elementPolicyKeyName);
}
public void InvokeAddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
ConfigurationElement configurationObject,
IConfigurationSource configurationSource,
String parentKey)
{
this.AddAdministrativeTemplateDirectives(contentBuilder,
configurationObject,
configurationSource,
parentKey);
}
protected internal override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
ConfigurationElement configurationObject,
IConfigurationSource configurationSource,
String parentKey)
{
this.wrappedProvider.AddAdministrativeTemplateDirectives(contentBuilder,
configurationObject,
configurationSource,
parentKey);
}
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
LoggingExceptionHandlerData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
AddElementAdministrativeTemplateParts(contentBuilder,
configurationObject,
configurationSource,
elementPolicyKeyName);
}
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
CustomCacheStorageData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
// parts for stores are part of their cache manager's policies
AddElementAdministrativeTemplateParts(contentBuilder,
configurationObject,
configurationSource,
elementPolicyKeyName);
}
/// <summary>
/// Adds the ADM instructions that describe the policies that can be used to override the properties of
/// a specific instance of the configuration element type managed by the receiver.
/// </summary>
/// <param name="contentBuilder">The <see cref="AdmContentBuilder"/> to which the Adm instructions are to be appended.</param>
/// <param name="configurationObject">The configuration object instance.</param>
/// <param name="configurationSource">The configuration source from where to get additional configuration
/// information, if necessary.</param>
/// <param name="elementPolicyKeyName">The key for the element's policies.</param>
/// <remarks>
/// The default implementation for this method creates a policy, using
/// <see cref="ConfigurationElementManageabilityProviderBase{T}.ElementPolicyNameTemplate"/> to create the policy name and invoking
/// <see cref="ConfigurationElementManageabilityProviderBase{T}.AddElementAdministrativeTemplateParts(AdmContentBuilder, T, IConfigurationSource, String)"/>
/// to add the policy parts.
/// Subclasses managing objects that must not create a policy must override this method to just add the parts.
/// </remarks>
protected override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
FaultContractExceptionHandlerData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
// directives are parts of the exception type policy
AddElementAdministrativeTemplateParts(contentBuilder,
configurationObject,
configurationSource,
elementPolicyKeyName);
}
public void CanCreateCategory()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.EndCategory();
AdmContent content = builder.GetContent();
Assert.IsNotNull(content);
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
Assert.IsTrue(categoriesEnumerator.MoveNext());
Assert.AreEqual("category", categoriesEnumerator.Current.Name);
Assert.IsFalse(categoriesEnumerator.MoveNext());
}
public static AdmContent GenerateAdministrativeTemplateContent(IConfigurationSource configurationSource, string applicationName, IDictionary<string, ConfigurationSectionManageabilityProvider> manageabilityProviders)
{
AdmContentBuilder contentBuilder = new AdmContentBuilder();
contentBuilder.StartCategory(applicationName);
foreach (KeyValuePair<string, ConfigurationSectionManageabilityProvider> pair in manageabilityProviders)
{
ConfigurationSection configurationObject = configurationSource.GetSection(pair.Key);
if (configurationObject != null)
{
pair.Value.AddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, applicationName);
}
}
contentBuilder.EndCategory();
return contentBuilder.GetContent();
}
public override void AddAdministrativeTemplateDirectives(AdmContentBuilder contentBuilder,
ConfigurationElement configurationObject,
IConfigurationSource configurationSource,
String parentKey)
{
called = true;
configurationObjects.Add(configurationObject);
if (addPolicy)
contentBuilder.StartPolicy(Policy, "policy");
if (addPart)
contentBuilder.AddTextPart(Part);
if (addPolicy)
contentBuilder.EndPolicy();
}
public void AddEditTextWithInvalidMaxLengthThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
builder.AddEditTextPart("part", "key", "value", "default", 1100, true);
}
public void StartPolicyFailsIfThereAreNoCategories()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartPolicy("name", "key");
}
public void CanAddEditTextPartWithKeyName()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
builder.AddEditTextPart("part", "key", "value", "default", 10, true);
builder.EndPolicy();
builder.EndCategory();
AdmContent content = builder.GetContent();
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator<AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
policiesEnumerator.MoveNext();
IEnumerator<AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual("part", ((AdmEditTextPart)partsEnumerator.Current).PartName);
Assert.AreEqual("key", ((AdmEditTextPart)partsEnumerator.Current).KeyName);
Assert.AreEqual("value", ((AdmEditTextPart)partsEnumerator.Current).ValueName);
Assert.AreEqual("default", ((AdmEditTextPart)partsEnumerator.Current).DefaultValue);
Assert.AreEqual(10, ((AdmEditTextPart)partsEnumerator.Current).Maxlen);
Assert.AreEqual(true, ((AdmEditTextPart)partsEnumerator.Current).Required);
}
public void AddComboBoxPartWithInvalidMaxLengthThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
builder.AddComboBoxPart("part", "key", "value", "default", 1100, true, "sug1", "sug2", "suggestion");
}
public void StartPolicyWithInvalidPolicyKeyThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "rkjerlejkre\\fe\"lkfelk*(*\\teflkj");
}
public void CanAddDropDownListPartForConfigurationElementsCollectionAllowingNoneAndEmptyDefault()
{
NamedElementCollection<NamedConfigurationElement> collection = new NamedElementCollection<NamedConfigurationElement>();
collection.Add(new NamedConfigurationElement("name1"));
collection.Add(new NamedConfigurationElement("name2"));
collection.Add(new NamedConfigurationElement("name3"));
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
builder.AddDropDownListPartForNamedElementCollection<NamedConfigurationElement>("part", "value", collection, "", true);
builder.EndPolicy();
builder.EndCategory();
AdmContent content = builder.GetContent();
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator<AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
policiesEnumerator.MoveNext();
IEnumerator<AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmDropDownListPart), partsEnumerator.Current.GetType());
Assert.AreEqual("part", ((AdmDropDownListPart)partsEnumerator.Current).PartName);
Assert.AreEqual(null, ((AdmDropDownListPart)partsEnumerator.Current).KeyName);
Assert.AreEqual("value", ((AdmDropDownListPart)partsEnumerator.Current).ValueName);
IEnumerator<AdmDropDownListItem> itemsEnumerator = ((AdmDropDownListPart)partsEnumerator.Current).Items.GetEnumerator();
Assert.IsTrue(itemsEnumerator.MoveNext());
Assert.AreEqual(AdmContentBuilder.NoneListItem, itemsEnumerator.Current.Value);
Assert.IsTrue(itemsEnumerator.MoveNext());
Assert.AreEqual("name1", itemsEnumerator.Current.Name);
Assert.IsTrue(itemsEnumerator.MoveNext());
Assert.AreEqual("name2", itemsEnumerator.Current.Name);
Assert.IsTrue(itemsEnumerator.MoveNext());
Assert.AreEqual("name3", itemsEnumerator.Current.Name);
Assert.IsFalse(itemsEnumerator.MoveNext());
}
public void CanAddDropDownListPartWithKeyName()
{
List<AdmDropDownListItem> items = new List<AdmDropDownListItem>();
items.Add(new AdmDropDownListItem("1", "1"));
items.Add(new AdmDropDownListItem("2", "2"));
items.Add(new AdmDropDownListItem("3", "3"));
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
builder.AddDropDownListPart("part", "key", "value", items, "1");
builder.EndPolicy();
builder.EndCategory();
AdmContent content = builder.GetContent();
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator<AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
policiesEnumerator.MoveNext();
IEnumerator<AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmDropDownListPart), partsEnumerator.Current.GetType());
Assert.AreEqual("part", ((AdmDropDownListPart)partsEnumerator.Current).PartName);
Assert.AreEqual("key", ((AdmDropDownListPart)partsEnumerator.Current).KeyName);
Assert.AreEqual("value", ((AdmDropDownListPart)partsEnumerator.Current).ValueName);
Assert.AreEqual("1", ((AdmDropDownListPart)partsEnumerator.Current).DefaultValue);
IEnumerator<AdmDropDownListItem> itemsEnumerator = ((AdmDropDownListPart)partsEnumerator.Current).Items.GetEnumerator();
Assert.IsTrue(itemsEnumerator.MoveNext());
Assert.AreEqual("1", itemsEnumerator.Current.Name);
Assert.IsTrue(itemsEnumerator.MoveNext());
Assert.AreEqual("2", itemsEnumerator.Current.Name);
Assert.IsTrue(itemsEnumerator.MoveNext());
Assert.AreEqual("3", itemsEnumerator.Current.Name);
Assert.IsFalse(itemsEnumerator.MoveNext());
}
public void CanAddCheckboxPartWithValueOnAndOff()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
;
builder.AddCheckboxPart("part", "value", true, true, false);
builder.EndPolicy();
builder.EndCategory();
AdmContent content = builder.GetContent();
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator<AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
policiesEnumerator.MoveNext();
IEnumerator<AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmCheckboxPart), partsEnumerator.Current.GetType());
Assert.AreEqual("part", ((AdmCheckboxPart)partsEnumerator.Current).PartName);
Assert.AreEqual(null, ((AdmCheckboxPart)partsEnumerator.Current).KeyName);
Assert.AreEqual("value", ((AdmCheckboxPart)partsEnumerator.Current).ValueName);
Assert.AreEqual(true, ((AdmCheckboxPart)partsEnumerator.Current).CheckedByDefault);
Assert.AreEqual(true, ((AdmCheckboxPart)partsEnumerator.Current).ValueForOn);
Assert.AreEqual(false, ((AdmCheckboxPart)partsEnumerator.Current).ValueForOff);
}
public void StartPolicyWithInvalidNameThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("dfhfdas\"fdjd", "key");
}
public void AddPartWithoutStartedPolicyThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.AddPart(new AdmTextPart("text"));
}
public void EndCategoryWithoutStartThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.EndCategory();
}
public void StartPolicyWithLongPolicyKeyThrows()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
String keyName = stringBuilder.ToString();
Assert.IsTrue(keyName.Length > 255);
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "parent\\" + keyName + "\\child");
}
public void AddEditTextWithDefaultValueLongerThanMaxLengthThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
builder.AddEditTextPart("part", "key", "value", "123456789012345678901", 20, true);
}
public void StartPolicyWithEmptyNameThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("", "key");
}
public void CanAddTextPart()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
builder.AddTextPart("part");
builder.EndPolicy();
builder.EndCategory();
AdmContent content = builder.GetContent();
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator<AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
policiesEnumerator.MoveNext();
IEnumerator<AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual("part", ((AdmTextPart)partsEnumerator.Current).PartName);
}
public void StartPolicyFailsIfThereIsACurrentStartedPolicy()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("name", "key");
builder.StartPolicy("name", "key");
}
public void CanAddDropDownListPartForEnumerationWithKeyName()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
builder.AddDropDownListPartForEnumeration<UriFormat>("part", "key", "value", UriFormat.UriEscaped);
builder.EndPolicy();
builder.EndCategory();
AdmContent content = builder.GetContent();
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator<AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
policiesEnumerator.MoveNext();
IEnumerator<AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmDropDownListPart), partsEnumerator.Current.GetType());
Assert.AreEqual("part", ((AdmDropDownListPart)partsEnumerator.Current).PartName);
Assert.AreEqual("key", ((AdmDropDownListPart)partsEnumerator.Current).KeyName);
Assert.AreEqual("value", ((AdmDropDownListPart)partsEnumerator.Current).ValueName);
Assert.AreEqual(UriFormat.UriEscaped.ToString(), ((AdmDropDownListPart)partsEnumerator.Current).DefaultValue);
Dictionary<String, String> items = new Dictionary<String, String>();
foreach (AdmDropDownListItem item in ((AdmDropDownListPart)partsEnumerator.Current).Items)
{
items.Add(item.Name, item.Value);
}
foreach (String name in Enum.GetNames(typeof(UriFormat)))
{
Assert.IsTrue(items.ContainsKey(name));
}
}
public void CanCreatePolicyInNestedCategory()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartCategory("subcategory");
builder.StartPolicy("policy", "key");
builder.EndPolicy();
builder.EndCategory();
builder.EndCategory();
AdmContent content = builder.GetContent();
Assert.IsNotNull(content);
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
Assert.IsTrue(categoriesEnumerator.MoveNext());
Assert.AreEqual("category", categoriesEnumerator.Current.Name);
IEnumerator<AdmCategory> subCategoriesEnumerator = categoriesEnumerator.Current.Categories.GetEnumerator();
Assert.IsTrue(subCategoriesEnumerator.MoveNext());
Assert.AreEqual("subcategory", subCategoriesEnumerator.Current.Name);
IEnumerator<AdmPolicy> policiesEnumerator = subCategoriesEnumerator.Current.Policies.GetEnumerator();
Assert.IsTrue(policiesEnumerator.MoveNext());
Assert.AreEqual("policy", policiesEnumerator.Current.Name);
Assert.IsFalse(policiesEnumerator.MoveNext());
Assert.IsFalse(subCategoriesEnumerator.MoveNext());
Assert.IsFalse(categoriesEnumerator.MoveNext());
}
public void AddCheckBoxWithInvalidValueNameThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
;
builder.AddCheckboxPart("policy", "invalid\"value", true, true, false);
}
public void StartPolicyWithEmptyPolicyKeyThrows()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "");
}
public void AddCheckBoxWithLongValueNameThrows()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
stringBuilder.Append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
String valueName = stringBuilder.ToString();
Assert.IsTrue(valueName.Length > 255);
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
;
builder.AddCheckboxPart("policy", valueName, true, true, false);
}
public void CanAddComboBoxPartWithKeyName()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
builder.AddComboBoxPart("part", "key", "value", "default", 10, true, "sug1", "sug2");
builder.EndPolicy();
builder.EndCategory();
AdmContent content = builder.GetContent();
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator<AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
policiesEnumerator.MoveNext();
IEnumerator<AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmComboBoxPart), partsEnumerator.Current.GetType());
Assert.AreEqual("part", ((AdmComboBoxPart)partsEnumerator.Current).PartName);
Assert.AreEqual("key", ((AdmComboBoxPart)partsEnumerator.Current).KeyName);
Assert.AreEqual("value", ((AdmComboBoxPart)partsEnumerator.Current).ValueName);
Assert.AreEqual("default", ((AdmComboBoxPart)partsEnumerator.Current).DefaultValue);
//Assert.AreEqual(10, ((AdmComboBoxPart)partsEnumerator.Current).Maxlen); // because of workaround for GPMC bug
Assert.AreEqual(true, ((AdmComboBoxPart)partsEnumerator.Current).Required);
IEnumerator<String> suggestionsEnumerator = ((AdmComboBoxPart)partsEnumerator.Current).Suggestions.GetEnumerator();
Assert.IsTrue(suggestionsEnumerator.MoveNext());
Assert.AreEqual("sug1", suggestionsEnumerator.Current);
Assert.IsTrue(suggestionsEnumerator.MoveNext());
Assert.AreEqual("sug2", suggestionsEnumerator.Current);
Assert.IsFalse(suggestionsEnumerator.MoveNext());
}
public void CanCreatePolicyInTopLevelCategory()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.StartCategory("category");
builder.StartPolicy("policy", "key");
builder.EndPolicy();
builder.EndCategory();
AdmContent content = builder.GetContent();
Assert.IsNotNull(content);
IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
Assert.IsTrue(categoriesEnumerator.MoveNext());
Assert.AreEqual("category", categoriesEnumerator.Current.Name);
IEnumerator<AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
Assert.IsTrue(policiesEnumerator.MoveNext());
Assert.AreEqual("policy", policiesEnumerator.Current.Name);
Assert.AreEqual("key", policiesEnumerator.Current.KeyName);
Assert.AreEqual(AdmContentBuilder.AvailableValueName, policiesEnumerator.Current.ValueName);
Assert.IsFalse(policiesEnumerator.MoveNext());
Assert.IsFalse(categoriesEnumerator.MoveNext());
}
public void EndPolicyFailsIfThereIsNoCurrentStartedPolicy()
{
AdmContentBuilder builder = new AdmContentBuilder();
builder.EndPolicy();
}
