bool OverrideWithGroupPoliciesForOracleConnection(OracleConnectionData connectionData,
bool readGroupPolicies,
IRegistryKey machineKey,
IRegistryKey userKey)
{
if (readGroupPolicies)
{
IRegistryKey policyKey = machineKey ?? userKey;
if (policyKey != null)
{
if (policyKey.IsPolicyKey && !policyKey.GetBoolValue(PolicyValueName).Value)
{
return(false);
}
try
{
String packagesOverride = policyKey.GetStringValue(PackagesPropertyName);
connectionData.Packages.Clear();
Dictionary <String, String> packagesDictionary = new Dictionary <string, string>();
KeyValuePairParser.ExtractKeyValueEntries(packagesOverride, packagesDictionary);
foreach (KeyValuePair <String, String> kvp in packagesDictionary)
{
connectionData.Packages.Add(new OraclePackageData(kvp.Key, kvp.Value));
}
}
catch (RegistryAccessException ex)
{
LogExceptionWhileOverriding(ex);
}
}
}
return(true);
}
public void ParseThrowsSyntaxError(string expression, int pos)
{
// Arrange & Act & Assert
Action test = () => KeyValuePairParser.Parse(expression);
ExceptionAssert.Throws <ODataException>(test, string.Format("Syntax error at position {0} in '{1}'.", pos, expression));
}
public void ManageabilityProviderGeneratesProperAdmContent()
{
configurationObject.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("name1", "value1"));
configurationObject.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("name2", "value2"));
configurationObject.ExceptionMessage = "message";
configurationObject.FaultContractType = "fault contract";
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
contentBuilder.StartCategory("category");
contentBuilder.StartPolicy("policy", "policy key");
provider.InvokeAddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, "TestApp");
contentBuilder.EndPolicy();
contentBuilder.EndCategory();
MockAdmContent content = contentBuilder.GetMockContent();
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(String.Format(Resources.HandlerPartNameTemplate, configurationObject.Name),
partsEnumerator.Current.PartName);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual(Resources.FaultContractExceptionHandlerExceptionMessagePartName, partsEnumerator.Current.PartName);
Assert.IsNotNull(partsEnumerator.Current.KeyName);
Assert.AreEqual(FaultContractExceptionHandlerDataManageabilityProvider.ExceptionMessagePropertyName,
partsEnumerator.Current.ValueName);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual(Resources.FaultContractExceptionHandlerFaultContractTypePartName, partsEnumerator.Current.PartName);
Assert.IsNotNull(partsEnumerator.Current.KeyName);
Assert.AreEqual(FaultContractExceptionHandlerDataManageabilityProvider.FaultContractTypePropertyName,
partsEnumerator.Current.ValueName);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual(Resources.FaultContractExceptionHandlerAttributesPartName, partsEnumerator.Current.PartName);
Assert.AreEqual(FaultContractExceptionHandlerDataManageabilityProvider.AttributesPropertyName,
partsEnumerator.Current.ValueName);
Assert.IsNotNull(((AdmEditTextPart)partsEnumerator.Current).KeyName);
IDictionary <String, String> attributes = new Dictionary <String, String>();
KeyValuePairParser.ExtractKeyValueEntries(((AdmEditTextPart)partsEnumerator.Current).DefaultValue, attributes);
Assert.AreEqual(2, attributes.Count);
Assert.AreEqual("value1", attributes["name1"]);
Assert.AreEqual("value2", attributes["name2"]);
Assert.IsFalse(partsEnumerator.MoveNext());
}
public void ParseThrowsMultipleLiteralsNotAllowed()
{
// Arrange & Act & Assert
Action test = () => KeyValuePairParser.Parse(" inOffice , xzg ");
ExceptionAssert.Throws <ODataException>(test, "' inOffice , xzg ' is not a valid expression.Single literal is only for single key. Multiple keys should use key=value.");
}
public ArgKeyValuePairs ParseToKeyValuePairs(params string[] args)
{
var parser = new KeyValuePairParser();
var jointArgs = string.Join(" ", args);
return(parser.Parse(jointArgs));
}
public void can_parse_a_single_pair()
{
var first = KeyValuePairParser.Parse("\"first\"=123").SingleOrDefault();
Assert.AreEqual("first", first.Key, "first.Key");
Assert.AreEqual(123, first.Value, "first.Value");
}
public void can_lex_string(string input, string expected)
{
var token = KeyValuePairParser.Lex(input).FirstOrDefault();
Assert.AreEqual(TokenType.String, token.Type);
Assert.AreEqual(expected, token.Value);
}
public void ParseMethodShouldReturnEmptyCollectionWhenArgsAreEmptyString(string args)
{
var collection = new KeyValuePairParser().Parse(args);
collection.Should().NotBeNull();
collection.Count.Should().Be(0);
}
public void can_lex_single_null()
{
var token = KeyValuePairParser.Lex("null").FirstOrDefault();
Assert.AreEqual(TokenType.Null, token.Type);
Assert.AreEqual(null, token.Value);
}
public void ParseThrowsUnterminatedStringLiteral()
{
// Arrange & Act & Assert
Action test = () => KeyValuePairParser.Parse(" inOffice='xzg ");
ExceptionAssert.Throws <ODataException>(test, "There is an unterminated string literal at position 16 in ' inOffice='xzg '.");
}
public void ManageabilityProviderGeneratesProperAdmContent()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
OracleConnectionData data1 = new OracleConnectionData();
section.OracleConnectionsData.Add(data1);
data1.Name = "data1";
data1.Packages.Add(new OraclePackageData("name1", "prefix1"));
data1.Packages.Add(new OraclePackageData("name2", "pre;fix2"));
OracleConnectionData data2 = new OracleConnectionData();
section.OracleConnectionsData.Add(data2);
data2.Name = "data2";
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
provider.InvokeAddAdministrativeTemplateDirectives(contentBuilder, section, configurationSource, "TestApp");
MockAdmContent content = contentBuilder.GetMockContent();
IEnumerator <AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
Assert.IsTrue(categoriesEnumerator.MoveNext());
Assert.AreEqual(Resources.DatabaseCategoryName, categoriesEnumerator.Current.Name);
IEnumerator <AdmCategory> subCategoriesEnumerator = categoriesEnumerator.Current.Categories.GetEnumerator();
Assert.IsTrue(subCategoriesEnumerator.MoveNext());
Assert.AreEqual(Resources.OracleConnectionsCategoryName, subCategoriesEnumerator.Current.Name);
IEnumerator <AdmPolicy> policiesEnumerator = subCategoriesEnumerator.Current.Policies.GetEnumerator();
Assert.IsTrue(policiesEnumerator.MoveNext());
Assert.AreEqual(String.Format(Resources.OracleConnectionPolicyNameTemplate, data1.Name),
policiesEnumerator.Current.Name);
IEnumerator <AdmPart> oracleDataPartsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(oracleDataPartsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), oracleDataPartsEnumerator.Current.GetType());
Assert.IsNull(oracleDataPartsEnumerator.Current.KeyName);
Assert.AreEqual(OracleConnectionSettingsManageabilityProvider.PackagesPropertyName,
oracleDataPartsEnumerator.Current.ValueName);
Assert.AreEqual(Resources.OracleConnectionPackagesPartName,
oracleDataPartsEnumerator.Current.PartName);
IDictionary <String, String> packages = new Dictionary <String, String>();
KeyValuePairParser.ExtractKeyValueEntries(((AdmEditTextPart)oracleDataPartsEnumerator.Current).DefaultValue, packages);
Assert.AreEqual(2, packages.Count);
Assert.AreEqual("prefix1", packages["name1"]);
Assert.AreEqual("pre;fix2", packages["name2"]);
Assert.IsFalse(oracleDataPartsEnumerator.MoveNext());
Assert.IsTrue(policiesEnumerator.MoveNext());
Assert.IsFalse(policiesEnumerator.MoveNext());
Assert.IsFalse(subCategoriesEnumerator.MoveNext());
IEnumerator <AdmPolicy> sectionPoliciesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
Assert.IsFalse(sectionPoliciesEnumerator.MoveNext());
Assert.IsFalse(categoriesEnumerator.MoveNext());
}
public void ParseReturnsNullForNullEmptyOrWhitespaceString(string expression)
{
// Arrange & Act
IDictionary <string, string> pairs = KeyValuePairParser.Parse(expression);
// Assert
Assert.Null(pairs);
}
public void can_lex_single_token(string input, object expected)
{
TokenType expectedTT = (TokenType)expected;
var token = KeyValuePairParser.Lex(input).FirstOrDefault();
Assert.AreEqual(expectedTT, token.Type);
Assert.AreEqual(input, token.Value);
}
public void ParseMethodShouldParseSingleKeyValueParameterWithDoubleSlash(string args, string expectedKey, string expectedValue)
{
var collection = new KeyValuePairParser().Parse(args);
collection.Should().NotBeNull();
collection.Count.Should().Be(1);
collection[0].Key.Should().Be(expectedKey);
collection[0].Value.Should().Be(expectedValue);
}
public void ParseForParameterAliasWorks(string expression)
{
// Arrange & Act
IDictionary <string, string> pairs = KeyValuePairParser.Parse(expression);
Assert.NotNull(pairs);
Assert.Equal(2, pairs.Count);
Assert.Equal("@p1", pairs["123"]);
Assert.Equal("@p2", pairs["myname"]);
}
/// <summary>
///
/// </summary>
/// <param name="routeValues"></param>
/// <param name="parameterMappings"></param>
/// <returns></returns>
internal static bool IsMatchParameters(RouteValueDictionary routeValues, IDictionary <string, string> parameterMappings)
{
Contract.Assert(routeValues != null);
Contract.Assert(parameterMappings != null);
// If we have a function(p1, p2, p3), where p3 is optinal parameter.
// In controller, we may have two functions:
// IActionResult function(p1, p2) --> #1
// IActionResult function(p1, p2, p3) --> #2
// #1 can match request like: ~/function(p1=a, p2=b) , where p1=a, p2=b (----a)
// It also match request like: ~/function(p1=a,p2=b,p3=c), where p2="b,p3=c". (----b)
// However, b request should match the #2 method and skip the #1 method.
// Here is a workaround:
// 1) We get all the parameters from the function and all parameter values from routeValue.
// Combine them as a string. so, actualParameters = "p1=a,p2=b,p3=c"
IDictionary <string, string> actualParameters = new Dictionary <string, string>();
foreach (var parameter in parameterMappings)
{
// For a parameter mapping like: minSalary={min}
// and a request like: ~/MyFunction(minSalary=2)
// the routeValue includes the [min=2], so we should use the mapping name to retrieve the value.
string parameterTemp = parameter.Value;
if (routeValues.TryGetValue(parameterTemp, out object rawValue))
{
actualParameters[parameterTemp] = rawValue as string;
}
}
if (!actualParameters.Any())
{
if (parameterMappings.Any())
{
return(false);
}
else
{
return(true);
}
}
string combintes = string.Join(",", actualParameters.Select(kvp => kvp.Key + "=" + kvp.Value));
// 2) Extract the key/value pairs
// p1=a p2=b p3=c
if (!KeyValuePairParser.TryParse(combintes, out IDictionary <string, string> parsedKeyValues))
{
return(false);
}
// 3) now the RequiredParameters (p1, p3) is not equal to actualParameters (p1, p2, p3)
return(parameterMappings.Count == actualParameters.Keys.Count);
}
/// <summary>
/// Try to parse the route key value from route values and save the parsed values into update values.
/// </summary>
/// <param name="routeValues">The original route value from request.</param>
/// <param name="updateValues">The updated/parsed route value.</param>
/// <param name="parameterMappings">The parameter (request key) and argument (parameter name in the action) mapping.</param>
/// <returns>true/false.</returns>
public static bool TryParseRouteKey(RouteValueDictionary routeValues, RouteValueDictionary updateValues, IDictionary <string, string> parameterMappings)
{
if (routeValues == null)
{
throw Error.ArgumentNull(nameof(routeValues));
}
if (updateValues == null)
{
throw Error.ArgumentNull(nameof(updateValues));
}
// format the route key
string routeKey = parameterMappings.BuildRouteKey();
if (routeValues.TryGetValue(routeKey, out var value) && value != null)
{
string parameterValueString = Convert.ToString(value, CultureInfo.InvariantCulture);
if (parameterValueString == null)
{
return(false);
}
// Parse the string from request into key/value pairs
if (KeyValuePairParser.TryParse(parameterValueString, out IDictionary <string, string> parsedKeyValues))
{
// for single key pattern
if (parsedKeyValues.Count == 1 && parsedKeyValues.ContainsKey(string.Empty) &&
parameterMappings.Count == 1)
{
updateValues[parameterMappings.First().Value] = parsedKeyValues[string.Empty];
return(true);
}
// We should compare the parameters from request and parameter/template mapping.
if (!IsRouteKeyAndParameterMatch(parameterMappings, parsedKeyValues))
{
return(false);
}
foreach (var parameter in parsedKeyValues)
{
// We don't need to verify {parameter.Key} whether it's in the parameterMappings or not.
// Because we did it in "IsRouteKeyAndParameterMatch" method
string templateName = parameterMappings[parameter.Key];
updateValues[templateName] = parameter.Value;
}
return(true);
}
}
return(false);
}
public void ParseComplexFunctionParametersWorks(string expression)
{
// Arrange & Act
IDictionary <string, string> pairs = KeyValuePairParser.Parse(expression);
Assert.NotNull(pairs);
Assert.Equal(3, pairs.Count);
Assert.Equal("true", pairs["123"]);
Assert.Equal("12345", pairs["inOffice"]);
Assert.Equal("'abc,''efg'", pairs["name"]);
}
public void ParseRetunsCorrectlyForSingleLiteralAndKeyValue(string expression)
{
// Arrange & Act
IDictionary <string, string> pairs = KeyValuePairParser.Parse(expression);
// Assert
Assert.NotNull(pairs);
Assert.Equal(2, pairs.Count);
Assert.Equal("xzg", pairs[string.Empty]);
Assert.Equal("1", pairs["inOffice"]);
}
public void ParseMethodShouldParseDoubleKeyValueParameterWithEqualsSign(string args, int expectedLength, string[] expectedKeys, string[] expectedValues)
{
var collection = new KeyValuePairParser().Parse(args);
collection.Should().NotBeNull();
collection.Count.Should().Be(expectedLength);
for (var i = 0; i < collection.Count; i++)
{
collection[i].Key.Should().Be(expectedKeys[i]);
collection[i].Value.Should().Be(expectedValues[i]);
}
}
public void ParseMethodShouldBeAbleToParseDistinctTypes(string args, int expectedLength, string[] expectedKeys, string[] expectedValues)
{
var collection = new KeyValuePairParser().Parse(args);
collection.Should().NotBeNull();
collection.Count.Should().Be(expectedLength);
for (var i = 0; i < collection.Count; i++)
{
collection[i].Key.Should().Be(expectedKeys[i]);
collection[i].Value.Should().Be(expectedValues[i]);
}
}
private List <Dictionary <string, string> > ParseApplicableInstructions()
{
List <Dictionary <string, string> > instructions = new List <Dictionary <string, string> >();
foreach (string platformName in this.ApplicablePlatformNamesMostGeneralFirst)
{
string resourceManifest = this.library.Metadata.ReadFile(false, "native/" + platformName + "/manifest.txt", true).Trim();
if (resourceManifest.Length == 0)
{
continue;
}
foreach (string lineRaw in resourceManifest.Split('\n'))
{
string line = lineRaw.Trim();
if (line.Length == 0 || line[0] == '#')
{
continue; // blank or comment
}
string[] parts = line.Split(COLON_CHAR, 2);
string command = parts[0].ToUpperInvariant().Trim();
Dictionary <string, string> values = KeyValuePairParser.Parse(parts[1]);
if (values == null)
{
throw new InvalidOperationException("The library '" + this.library.Metadata.ID + "' has a malformed copy instruction on the following line: " + lineRaw);
}
values["TYPE"] = command;
// pre-pend the current directory to any attributes that have a path. Currently this is just "from".
switch (command)
{
case "COPY_FILE":
case "COPY_FILES":
case "EMBED_FILE":
case "EMBED_FILES":
case "DOTNET_DLL":
if (values.ContainsKey("from"))
{
values["from"] = platformName + "/" + values["from"];
}
break;
}
instructions.Add(values);
}
}
return(instructions);
}
public void ManageabilityProviderGeneratesProperAdmContent()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationObject.Type = typeof(object);
configurationObject.Attributes.Add("name1", "valu;e1");
configurationObject.Attributes.Add("name2", "value2");
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
contentBuilder.StartCategory("category");
contentBuilder.StartPolicy("policy", "policy key");
provider.AddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, "TestApp");
contentBuilder.EndPolicy();
contentBuilder.EndCategory();
MockAdmContent content = contentBuilder.GetMockContent();
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.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual(CustomHandlerDataManageabilityProvider.ProviderTypePropertyName,
partsEnumerator.Current.ValueName);
Assert.IsNotNull(partsEnumerator.Current.KeyName);
Assert.AreEqual(typeof(object).AssemblyQualifiedName, ((AdmEditTextPart)partsEnumerator.Current).DefaultValue);
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmEditTextPart), partsEnumerator.Current.GetType());
Assert.AreEqual(CustomHandlerDataManageabilityProvider.AttributesPropertyName,
partsEnumerator.Current.ValueName);
Assert.IsNotNull(partsEnumerator.Current.KeyName);
IDictionary <String, String> attributes = new Dictionary <String, String>();
KeyValuePairParser.ExtractKeyValueEntries(((AdmEditTextPart)partsEnumerator.Current).DefaultValue, attributes);
Assert.AreEqual(2, attributes.Count);
Assert.AreEqual("valu;e1", attributes["name1"]);
Assert.AreEqual("value2", attributes["name2"]);
Assert.IsFalse(partsEnumerator.MoveNext());
}
public void can_parse_a_multiple_pairs()
{
var seq = KeyValuePairParser.Parse("\"first\"=123,\"second\"=true");
var first = seq.ElementAt(0);
Assert.AreEqual("first", first.Key, "first.Key");
Assert.AreEqual(123, first.Value, "first.Value");
var second = seq.ElementAt(1);
Assert.AreEqual("second", second.Key, "second.Key");
Assert.AreEqual(true, second.Value, "second.Value");
Assert.AreEqual(2, seq.Count());
}
public void TryParseWorksForSingleKeyString(string expression)
{
// Arrange & Act
IDictionary <string, string> pairs1 = KeyValuePairParser.Parse(expression);
bool result = KeyValuePairParser.TryParse(expression, out IDictionary <string, string> pairs2);
// Assert
Assert.True(result);
Assert.Equal(pairs1, pairs2);
KeyValuePair <string, string> keyValue = Assert.Single(pairs1);
Assert.Equal(string.Empty, keyValue.Key);
Assert.Equal("'abc'", keyValue.Value);
}
protected override void OverrideWithGroupPolicies(AuthorizationRuleProviderData configurationObject, IRegistryKey policyKey)
{
String rulesOverride = policyKey.GetStringValue(RulesPropertyName);
if (rulesOverride != null)
{
configurationObject.Rules.Clear();
Dictionary <String, String> attributesDictionary = new Dictionary <string, string>();
KeyValuePairParser.ExtractKeyValueEntries(rulesOverride, attributesDictionary);
foreach (KeyValuePair <String, String> kvp in attributesDictionary)
{
configurationObject.Rules.Add(new AuthorizationRuleData(kvp.Key, kvp.Value));
}
}
}
public static bool SaveChanges(OracleConnectionSetting setting, ConfigurationElement sourceElement)
{
OracleConnectionData element = (OracleConnectionData)sourceElement;
Dictionary <String, String> packagesDictionary = new Dictionary <string, string>();
foreach (string encodedKeyValuePair in setting.Packages)
{
KeyValuePairParser.ExtractKeyValueEntries(encodedKeyValuePair, packagesDictionary);
}
element.Packages.Clear();
foreach (KeyValuePair <String, String> kvp in packagesDictionary)
{
element.Packages.Add(new OraclePackageData(kvp.Key, kvp.Value));
}
return(true);
}
protected override void OverrideWithGroupPolicies(FaultContractExceptionHandlerData configurationObject, IRegistryKey policyKey)
{
String attributesOverride = policyKey.GetStringValue(AttributesPropertyName);
String exceptionMessageOverride = policyKey.GetStringValue(ExceptionMessagePropertyName);
String faultContractTypeOverride = policyKey.GetStringValue(FaultContractTypePropertyName);
configurationObject.ExceptionMessage = exceptionMessageOverride;
configurationObject.FaultContractType = faultContractTypeOverride;
configurationObject.PropertyMappings.Clear();
Dictionary <String, String> attributesDictionary = new Dictionary <string, string>();
KeyValuePairParser.ExtractKeyValueEntries(attributesOverride, attributesDictionary);
foreach (KeyValuePair <String, String> kvp in attributesDictionary)
{
configurationObject.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData(kvp.Key, kvp.Value));
}
}
public void can_lex_sequence_of_tokens()
{
var tokens = KeyValuePairParser.Lex("\"first\"=123,\"second\"=true").GetEnumerator();
Assert.AreEqual(true, tokens.MoveNext(), "first");
Assert.AreEqual(new Token("first", TokenType.String), tokens.Current);
Assert.AreEqual(true, tokens.MoveNext(), "=");
Assert.AreEqual(new Token("=", TokenType.Equals), tokens.Current);
Assert.AreEqual(true, tokens.MoveNext(), "123");
Assert.AreEqual(new Token("123", TokenType.Number), tokens.Current);
Assert.AreEqual(true, tokens.MoveNext(), ",");
Assert.AreEqual(new Token(",", TokenType.Comma), tokens.Current);
Assert.AreEqual(true, tokens.MoveNext(), "second");
Assert.AreEqual(new Token("second", TokenType.String), tokens.Current);
Assert.AreEqual(true, tokens.MoveNext(), "=");
Assert.AreEqual(new Token("=", TokenType.Equals), tokens.Current);
Assert.AreEqual(true, tokens.MoveNext(), "true");
Assert.AreEqual(new Token("true", TokenType.True), tokens.Current);
Assert.AreEqual(false, tokens.MoveNext(), "end");
}
private bool OverrideWithGroupPoliciesAndGenerateWmiObjectsForOracleConnection(OracleConnectionData connectionData,
bool readGroupPolicies, IRegistryKey machineKey, IRegistryKey userKey,
bool generateWmiObjects, ICollection <ConfigurationSetting> wmiSettings)
{
if (readGroupPolicies)
{
IRegistryKey policyKey = machineKey != null ? machineKey : userKey;
if (policyKey != null)
{
if (policyKey.IsPolicyKey && !policyKey.GetBoolValue(PolicyValueName).Value)
{
return(false);
}
try
{
String packagesOverride = policyKey.GetStringValue(PackagesPropertyName);
connectionData.Packages.Clear();
Dictionary <String, String> packagesDictionary = new Dictionary <string, string>();
KeyValuePairParser.ExtractKeyValueEntries(packagesOverride, packagesDictionary);
foreach (KeyValuePair <String, String> kvp in packagesDictionary)
{
connectionData.Packages.Add(new OraclePackageData(kvp.Key, kvp.Value));
}
}
catch (RegistryAccessException ex)
{
LogExceptionWhileOverriding(ex);
}
}
}
if (generateWmiObjects)
{
String[] packages = GeneratePackagesArray(connectionData.Packages);
wmiSettings.Add(new OracleConnectionSetting(connectionData.Name, packages));
}
return(true);
}
