public void NewTemporaryRegistryValueTest_RegistryKey_Success()
{
var testSubKeyPath = "FiveChecks.Tests";
Registry.CurrentUser.DeleteSubKey(testSubKeyPath, false);
using (Registry.CurrentUser.CreateSubKey(testSubKeyPath)){}
Some <string> valueName = "SomeValueName";
var actual = TemporaryRegistryValue.NewTemporaryRegistryValue(Registry.CurrentUser, testSubKeyPath, valueName, RegistryValueKind.DWord, 0);
var val = actual.Match(
value =>
{
Assert.IsTrue(actual.IsSuccess, "Expected success");
Assert.IsTrue(RegistryOperations.RegistryValueExists(Registry.CurrentUser, testSubKeyPath, valueName), "Temporary value does not exist.");
value.Dispose();
Assert.IsFalse(RegistryOperations.RegistryValueExists(Registry.CurrentUser, testSubKeyPath, valueName.Value), "Temporary value was not deleted.");
return(Option <object> .None);
},
exception =>
{
Assert.IsFalse(true, exception.Message);
return(Option <object> .None);
});
//Cleanup
Registry.CurrentUser.DeleteSubKey(testSubKeyPath, false);
}
public void NewTemporaryRegistryValueTest_RegistryKey_DoesNotExist_ErrorResult()
{
string nonExistingRegistryKeyPath = @"APathThat\Hardly\Exists";
var actual = TemporaryRegistryValue.NewTemporaryRegistryValue(Registry.CurrentUser, nonExistingRegistryKeyPath, "SomeValueName", RegistryValueKind.DWord, 0);
Assert.IsTrue(actual.IsFaulted);
var expectedExceptionMessage = $"Sub key '{Registry.CurrentUser.Name}\\{nonExistingRegistryKeyPath}' does not exist.";
var val = actual.Match(
value =>
{
Assert.IsFalse(actual.IsSuccess);
return(Option <object> .None);
},
exception =>
{
Assert.AreEqual(expectedExceptionMessage, exception.Message);
return(Option <object> .None);
});
}
public void NewTemporaryRegistryValueFTest(string description, object data)
{
var testData = data as TestData;
Assert.NotNull(testData, "Test data was null");
var testSubKeyPath = "FiveChecks.Tests";
Dictionary <string, object> registry = new Dictionary <string, object>();
if (testData.ExistingValue != null)
{
registry.Add(testData.ValueName, testData.ExistingValue);
}
var actualGetValueCallCount = 0;
var actualGetValueKindCallCount = 0;
var actualSetValueCallCount = 0;
var actualDeleteValueCallCount = 0;
Func <string, object, object> getValue = (valueName, defaultValue) =>
{
actualGetValueCallCount++;
if (registry.ContainsKey(valueName))
{
return(registry[valueName]);
}
return(defaultValue);
};
Func <string, RegistryValueKind> getValueKind = valueName =>
{
actualGetValueKindCallCount++;
return(testData.ExistingValueKind);
};
Action <string, object, RegistryValueKind> setValue = (valueName, value, valueKind) =>
{
actualSetValueCallCount++;
if (registry.ContainsKey(valueName))
{
registry[valueName] = value;
}
else
{
registry.Add(valueName, value);
}
};
Action <string> deleteValue = valueName =>
{
actualDeleteValueCallCount++;
if (registry.ContainsKey(valueName))
{
registry.Remove(valueName);
}
};
var actual = TemporaryRegistryValue.NewTemporaryRegistryValuePure(Registry.CurrentUser, testSubKeyPath, testData.ValueName, testData.ValueKind, testData.Value, getValue, getValueKind, setValue);
Assert.AreEqual(testData.ExpectedGetValueCallCount, actualGetValueCallCount, "GetValue call count.");
Assert.AreEqual(testData.ExpectedGetValueKindCallCount, actualGetValueKindCallCount, "GetValueKind call count.");
Assert.AreEqual(testData.ExpectedSetValueCallCount, actualSetValueCallCount, "SetValue call count.");
var res = actual.Match(
value =>
{
Assert.IsTrue(testData.ExpectedIsSuccess, "Did not expect success.");
Assert.AreEqual(testData.Value, getValue(testData.ValueName, null));
TemporaryRegistryValue.ReleaseTemporaryRegistryValuePure(testData.ValueName, testData.ExistingValue, testData.ExistingValueKind, setValue, deleteValue);
Assert.AreEqual(testData.ExpectedDeleteValueCallCount, actualDeleteValueCallCount, "DeleteValue call count.");
return(Option <object> .None);
},
exception =>
{
Assert.IsTrue(!testData.ExpectedIsSuccess, exception.ToString());
Assert.AreEqual(testData.ExpectedErrorMessage, exception.Message);
return(Option <object> .None);
});
}
