//Form of Ax^2 + Bx + C
//Takes array of double containing A,B,C
//Returns array of positive and negative result
public static double[] QuadFormula(double[] abc)
{
NotFiniteNumberException e = new NotFiniteNumberException();
try
{
double a = abc[0];
double b = abc[1];
double c = abc[2];
double discriminant = ((b * b) - (4 * a * c));
if (discriminant < 0.00)
{
throw e;
}
discriminant = (Math.Sqrt(discriminant));
Console.WriteLine("discriminant: {0}",discriminant);
double posAnswer = ((-b + discriminant) / (2 * a));
double negAnswer = ((-b - discriminant) / (2 * a));
double[] xArray= { posAnswer,negAnswer};
return xArray;
}
catch (NotFiniteNumberException)
{
Console.WriteLine("Both answers will be imaginary numbers");
double[] xArray = { Math.Sqrt(-1), Math.Sqrt(-1) };
return xArray;
}
}
public void CanCreatePoliciesForHandler()
{
ExceptionPolicyData exceptionPolicyData = new ExceptionPolicyData("policy");
settings.ExceptionPolicies.Add(exceptionPolicyData);
ExceptionTypeData exceptionTypeData = new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException);
exceptionPolicyData.ExceptionTypes.Add(exceptionTypeData);
FaultContractExceptionHandlerData exceptionHandlerData = new FaultContractExceptionHandlerData("handler1",
typeof(MockFaultContract).AssemblyQualifiedName);
exceptionHandlerData.ExceptionMessage = "fault message";
exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("Message", "{Message}"));
exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("Data", "{Data}"));
exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("SomeNumber", "{OffendingNumber}"));
exceptionTypeData.ExceptionHandlers.Add(exceptionHandlerData);
container.AddExtension(new ExceptionHandlingBlockExtension());
ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy");
NotFiniteNumberException originalException = new NotFiniteNumberException("MyException", 12341234123412);
originalException.Data.Add("someKey", "someValue");
try
{
policy.HandleException(originalException);
Assert.Fail("a new exception should have been thrown");
}
catch (FaultContractWrapperException e)
{
MockFaultContract fault = (MockFaultContract)e.FaultContract;
Assert.AreEqual(originalException.Message, fault.Message);
Assert.AreEqual(originalException.Data.Count, fault.Data.Count);
Assert.AreEqual(originalException.Data["someKey"], fault.Data["someKey"]);
Assert.AreEqual(originalException.OffendingNumber, fault.SomeNumber);
}
}
public void CreatesWcfExceptionShildingProgrammatically()
{
var excepionPolicies = new List <ExceptionPolicyDefinition>();
var excepionPolicyEntries = new List <ExceptionPolicyEntry>();
var attributes = new NameValueCollection {
{ "Message", "{Message}" }, { "Data", "{Data}" }, { "SomeNumber", "{OffendingNumber}" }
};
var exceptionHandler = new FaultContractExceptionHandler(typeof(MockFaultContract), "fault message", attributes);
var exceptionPolicy = new ExceptionPolicyEntry(typeof(NotFiniteNumberException), PostHandlingAction.ThrowNewException, new IExceptionHandler[] { exceptionHandler });
excepionPolicyEntries.Add(exceptionPolicy);
excepionPolicies.Add(new ExceptionPolicyDefinition("Wcf Shielding Policy", excepionPolicyEntries));
var exceptionManager = new ExceptionManager(excepionPolicies);
NotFiniteNumberException originalException = new NotFiniteNumberException("MyException", 555);
originalException.Data.Add("someKey", "someValue");
try
{
exceptionManager.HandleException(originalException, "Wcf Shielding Policy");
Assert.Fail("a new exception should have been thrown");
}
catch (FaultContractWrapperException ex)
{
MockFaultContract fault = (MockFaultContract)ex.FaultContract;
Assert.AreEqual(originalException.Message, fault.Message);
Assert.AreEqual(originalException.Data.Count, fault.Data.Count);
Assert.AreEqual(originalException.Data["someKey"], fault.Data["someKey"]);
Assert.AreEqual(originalException.OffendingNumber, fault.SomeNumber);
}
}
// Test the NotFiniteNumberException class.
public void TestNotFiniteNumberException()
{
NotFiniteNumberException e;
e = new NotFiniteNumberException();
AssertEquals("NotFiniteNumberException (1)",
0.0, e.OffendingNumber);
AssertNotNull("NotFiniteNumberException (2)", e.Message);
ExceptionTester.CheckHResult
("NotFiniteNumberException (3)", e,
unchecked ((int)0x80131528));
e = new NotFiniteNumberException("msg");
AssertEquals("NotFiniteNumberException (4)",
0.0, e.OffendingNumber);
AssertEquals("NotFiniteNumberException (5)", "msg", e.Message);
ExceptionTester.CheckHResult
("NotFiniteNumberException (6)", e,
unchecked ((int)0x80131528));
e = new NotFiniteNumberException("msg", 2.0);
AssertEquals("NotFiniteNumberException (7)",
2.0, e.OffendingNumber);
AssertEquals("NotFiniteNumberException (8)",
"msg", e.Message);
ExceptionTester.CheckHResult
("NotFiniteNumberException (9)", e,
unchecked ((int)0x80131528));
}
public void BuildsWcfExceptionShildingWithFluentConfiguration()
{
DictionaryConfigurationSource emptyConfigSource = new DictionaryConfigurationSource();
ConfigurationSourceBuilder builder = new ConfigurationSourceBuilder();
builder.ConfigureExceptionHandling()
.GivenPolicyWithName("policy")
.ForExceptionType(typeof(NotFiniteNumberException))
.ShieldExceptionForWcf(typeof(MockFaultContract), "fault message")
.MapProperty("Message", "{Message}")
.MapProperty("Data", "{Data}")
.MapProperty("SomeNumber", "{OffendingNumber}")
.ThenThrowNewException();
builder.UpdateConfigurationWithReplace(emptyConfigSource);
ExceptionHandlingSettings settings = emptyConfigSource.GetSection(ExceptionHandlingSettings.SectionName) as ExceptionHandlingSettings;
Assert.IsNotNull(settings);
Assert.AreEqual(1, settings.ExceptionPolicies.Count);
var policy = settings.ExceptionPolicies.Get("policy");
Assert.IsNotNull(policy);
Assert.AreEqual(1, policy.ExceptionTypes.Count);
var configuredException = policy.ExceptionTypes.Get(0);
Assert.AreEqual(typeof(NotFiniteNumberException), configuredException.Type);
Assert.AreEqual(PostHandlingAction.ThrowNewException, configuredException.PostHandlingAction);
Assert.AreEqual(1, configuredException.ExceptionHandlers.Count);
var handler = configuredException.ExceptionHandlers.Get(0) as FaultContractExceptionHandlerData;
Assert.IsNotNull(handler);
Assert.AreEqual(typeof(MockFaultContract).AssemblyQualifiedName, handler.FaultContractType);
Assert.AreEqual("fault message", handler.ExceptionMessage);
Assert.AreEqual(3, handler.PropertyMappings.Count);
Assert.IsNotNull(handler.PropertyMappings.SingleOrDefault(p => p.Name == "Message" && p.Source == "{Message}"));
Assert.IsNotNull(handler.PropertyMappings.SingleOrDefault(p => p.Name == "Data" && p.Source == "{Data}"));
Assert.IsNotNull(handler.PropertyMappings.SingleOrDefault(p => p.Name == "SomeNumber" && p.Source == "{OffendingNumber}"));
var exceptionManager = settings.BuildExceptionManager();
NotFiniteNumberException originalException = new NotFiniteNumberException("MyException", 555);
originalException.Data.Add("someKey", "someValue");
try
{
exceptionManager.HandleException(originalException, "policy");
Assert.Fail("Should have thrown");
}
catch (FaultContractWrapperException ex)
{
MockFaultContract fault = (MockFaultContract)ex.FaultContract;
Assert.AreEqual(originalException.Message, fault.Message);
Assert.AreEqual(originalException.Data.Count, fault.Data.Count);
Assert.AreEqual(originalException.Data["someKey"], fault.Data["someKey"]);
Assert.AreEqual(originalException.OffendingNumber, fault.SomeNumber);
}
}
public static void Ctor_String()
{
string message = "Created NotFiniteNumberException";
var exception = new NotFiniteNumberException(message);
Assert.Equal(message, exception.Message);
Assert.Equal(COR_E_NOTFINITENUMBER, exception.HResult);
}
public static void Ctor_Double()
{
double offendingNumber = double.PositiveInfinity;
var exception = new NotFiniteNumberException(offendingNumber);
Assert.Equal(offendingNumber, exception.OffendingNumber);
Assert.Equal(COR_E_NOTFINITENUMBER, exception.HResult);
}
public static void Ctor_Empty()
{
var exception = new NotFiniteNumberException();
Assert.NotNull(exception);
Assert.NotEmpty(exception.Message);
Assert.Equal(COR_E_NOTFINITENUMBER, exception.HResult);
}
public static void Ctor_String_Double()
{
string message = "Created NotFiniteNumberException";
double offendingNumber = double.NegativeInfinity;
var exception = new NotFiniteNumberException(message, offendingNumber);
Assert.Equal(message, exception.Message);
Assert.Equal(offendingNumber, exception.OffendingNumber);
Assert.Equal(COR_E_NOTFINITENUMBER, exception.HResult);
}
public static void Ctor_String_Exception()
{
string message = "Created NotFiniteNumberException";
var innerException = new Exception("Created inner exception");
var exception = new NotFiniteNumberException(message, innerException);
Assert.Equal(message, exception.Message);
Assert.Equal(COR_E_NOTFINITENUMBER, exception.HResult);
Assert.Same(innerException, exception.InnerException);
Assert.Equal(innerException.HResult, exception.InnerException.HResult);
}
public void ResultsTest()
{
var r = Ok(4);
Assert.AreEqual(10, r + 6);
Result <int> resultInt = 5;
Assert.AreEqual(Ok(5), resultInt);
Assert.IsFalse(resultInt is IFailed);
var ex = new NotFiniteNumberException();
var e = Fail <int>(ex);
Assert.AreEqual(Fail <int>(ex), e);
Assert.IsFalse(e.Success);
Assert.AreEqual(4, r.ValueOrThrow());
Assert.ThrowsException <NotFiniteNumberException>(() => e.ValueOrThrow());
Assert.IsTrue(e is IFailed f && f.Error is NotFiniteNumberException);
Assert.AreEqual(8, e.ValueOrDefault(8));
Assert.AreEqual(ex.Message.Length, e.ValueOrElse(e => e.Message.Length));
Assert.AreEqual(Ok(true), resultInt.Chain(i => Ok(i * 2).Chain(j => Ok(j > i))));
Assert.AreEqual(e.Error, ((Fail <string>)e.Chain(_ => Ok($"Success!"))).Error);
Assert.AreEqual(Ok(9),
from a in r
from b in resultInt
select a + b);
Assert.AreEqual(e,
from a in r
from b in e
select a + b);
Assert.AreEqual("Success: 5", resultInt.Handle(v => $"Success: {v}", e => $"Failed with: {e.Message}"));
Assert.AreEqual("Failed with: " + ex.Message, e.Handle(v => $"Success: {v}", e => $"Failed with: {e.Message}"));
Assert.AreEqual(Ok(5), r.Combine(resultInt));
Assert.AreEqual(e, r.Combine(e));
Assert.AreEqual(e, e.Combine(r));
Assert.AreEqual(Ok(5), r & resultInt);
Assert.AreEqual(e, r & e);
Assert.AreEqual(e, e & r);
Assert.IsTrue(Ok(5) == Ok(5));
Assert.IsTrue(Ok(5) != Ok(6));
Assert.IsTrue(Fail(ex) == Fail(ex));
Assert.IsTrue(Fail(ex) != Fail(new ArgumentException()));
}
public void CanInjectInvalidPropertyValueIntoCustomPropertyFaultContract()
{
NameValueCollection attributes = new NameValueCollection();
attributes.Add("Invalid", "{OffendingNumber}");
FaultContractExceptionHandler instance = new FaultContractExceptionHandler(typeof(MockFaultContract), attributes);
NotFiniteNumberException exception = new NotFiniteNumberException("MyException", 1231254);
FaultContractWrapperException result = (FaultContractWrapperException)instance.HandleException(exception, Guid.NewGuid());
Assert.AreEqual((double)0, ((MockFaultContract)result.FaultContract).SomeNumber);
}
public static void Ctor_String_Double_Exception()
{
string message = "Created NotFiniteNumberException";
double offendingNumber = double.NaN;
var innerException = new Exception("Created inner exception");
var exception = new NotFiniteNumberException(message, offendingNumber, innerException);
Assert.Equal(offendingNumber, exception.OffendingNumber);
Assert.Equal(message, exception.Message);
Assert.Equal(innerException, exception.InnerException);
Assert.Equal(COR_E_NOTFINITENUMBER, exception.HResult);
}
public void can_create_a_failure_case_with_a_specific_exception()
{
var msg = "Example";
var error = new NotFiniteNumberException(msg);
var result = Result <string> .Failure(error); // note, we can't infer the type of a failure
Assert.IsFalse(result.IsSuccess);
Assert.IsTrue(result.IsFailure);
Assert.IsNull(result.ResultData);
Assert.AreEqual(result.FailureCause, error);
Assert.AreEqual(msg, result.FailureCause.Message);
}
public void CanInjectAttributesIntoFaultContract()
{
NameValueCollection attributes = new NameValueCollection();
attributes.Add("Message", "{Message}");
attributes.Add("Data", "{Data}");
attributes.Add("SomeNumber", "{OffendingNumber}");
FaultContractExceptionHandler instance = new FaultContractExceptionHandler(typeof(MockFaultContract), attributes);
NotFiniteNumberException exception = new NotFiniteNumberException("MyException", 12341234123412);
exception.Data.Add("someKey", "someValue");
FaultContractWrapperException result = (FaultContractWrapperException)instance.HandleException(exception, Guid.NewGuid());
MockFaultContract fault = (MockFaultContract)result.FaultContract;
Assert.AreEqual(exception.Message, fault.Message);
Assert.AreEqual(exception.Data.Count, fault.Data.Count);
Assert.AreEqual(exception.Data["someKey"], fault.Data["someKey"]);
Assert.AreEqual(exception.OffendingNumber, fault.SomeNumber);
}
// Test the NotFiniteNumberException class.
public void TestNotFiniteNumberException()
{
NotFiniteNumberException e;
e = new NotFiniteNumberException();
AssertEquals("NotFiniteNumberException (1)",
0.0, e.OffendingNumber);
AssertNotNull("NotFiniteNumberException (2)", e.Message);
ExceptionTester.CheckHResult
("NotFiniteNumberException (3)", e,
unchecked((int)0x80131528));
e = new NotFiniteNumberException("msg");
AssertEquals("NotFiniteNumberException (4)",
0.0, e.OffendingNumber);
AssertEquals("NotFiniteNumberException (5)", "msg", e.Message);
ExceptionTester.CheckHResult
("NotFiniteNumberException (6)", e,
unchecked((int)0x80131528));
e = new NotFiniteNumberException("msg", 2.0);
AssertEquals("NotFiniteNumberException (7)",
2.0, e.OffendingNumber);
AssertEquals("NotFiniteNumberException (8)",
"msg", e.Message);
ExceptionTester.CheckHResult
("NotFiniteNumberException (9)", e,
unchecked((int)0x80131528));
}
private static void Ex1(NotFiniteNumberException number)
{
throw new NotImplementedException();
}
static void Main(string[] args)
{
var number = new NotFiniteNumberException();
Ex1(number);
}
private int MapExceptionToNumber(Exception e)
{
Type type = e.GetType();
if (type == typeof(IndexOutOfRangeException))
{
return(9);
}
if (type == typeof(RankException))
{
return(9);
}
if (type == typeof(DivideByZeroException))
{
return(11);
}
if (type == typeof(OverflowException))
{
return(6);
}
if (type == typeof(NotFiniteNumberException))
{
NotFiniteNumberException exception = (NotFiniteNumberException)e;
if (exception.OffendingNumber == 0.0)
{
return(11);
}
return(6);
}
if (type == typeof(NullReferenceException))
{
return(0x5b);
}
if (e is AccessViolationException)
{
return(-2147467261);
}
if (type == typeof(InvalidCastException))
{
return(13);
}
if (type == typeof(NotSupportedException))
{
return(13);
}
if (type == typeof(COMException))
{
COMException exception2 = (COMException)e;
return(Utils.MapHRESULT(exception2.ErrorCode));
}
if (type == typeof(SEHException))
{
return(0x63);
}
if (type == typeof(DllNotFoundException))
{
return(0x35);
}
if (type == typeof(EntryPointNotFoundException))
{
return(0x1c5);
}
if (type == typeof(TypeLoadException))
{
return(0x1ad);
}
if (type == typeof(OutOfMemoryException))
{
return(7);
}
if (type == typeof(FormatException))
{
return(13);
}
if (type == typeof(DirectoryNotFoundException))
{
return(0x4c);
}
if (type == typeof(IOException))
{
return(0x39);
}
if (type == typeof(FileNotFoundException))
{
return(0x35);
}
if (e is MissingMemberException)
{
return(0x1b6);
}
if (e is InvalidOleVariantTypeException)
{
return(0x1ca);
}
return(5);
}
