public void TestClientOnlyUseMsCorLibTypes()
        {
            Exception e = new Exception();

            try
            {
                RpcExceptionInfo.Create(ThrownException, RpcErrorDetailBehavior.FullDetails)
                .ReThrow(RpcErrorTypeBehavior.OnlyUseMsCorLibTypes);
            }
            catch (Exception ex)
            {
                e = ex;
            }

            Assert.AreEqual(typeof(ArgumentNullException), e.GetType());
            Assert.AreEqual(ThrownException.Message, e.Message);

            //again with a different exception type that is not in mscore:
            try
            {
                RpcExceptionInfo.Create(AsThrown(new UninitializedMessageException(RpcVoid.DefaultInstance)),
                                        RpcErrorDetailBehavior.FullDetails)
                .ReThrow(RpcErrorTypeBehavior.OnlyUseMsCorLibTypes);
            }
            catch (Exception ex)
            {
                e = ex;
            }

            Assert.AreEqual(typeof(ApplicationException), e.GetType());
        }
        public void TestBehaviorMessageOnly()
        {
            RpcExceptionInfo msg = RpcExceptionInfo.Create(AsThrown(new InvalidOperationException("message")),
                                                           RpcErrorDetailBehavior.MessageOnly);

            Assert.IsTrue(msg.HasAssemblyName);
            Assert.IsTrue(msg.HasFullTypeName);
            Assert.IsTrue(msg.HasMessage);
            Assert.IsFalse(msg.HasSource);
            Assert.IsFalse(msg.HasStackTraceString);
            Assert.IsFalse(msg.HasRemoteStackTraceString);

            Assert.AreEqual(typeof(string).Assembly.FullName, msg.AssemblyName);
            Assert.AreEqual(typeof(InvalidOperationException).FullName, msg.FullTypeName);
            Assert.AreEqual("message", msg.Message);

            try
            {
                msg.ReThrow(RpcErrorTypeBehavior.OnlyUseLoadedAssemblies);
            }
            catch (Exception e)
            {
                Assert.AreEqual("message", e.Message);
                Assert.AreEqual(typeof(InvalidOperationException), e.GetType());
            }
        }
        public void TestBehaviorFullDetails()
        {
            RpcExceptionInfo msg = RpcExceptionInfo.Create(AsThrown(new InvalidOperationException("message")),
                                                           RpcErrorDetailBehavior.FullDetails);

            Assert.IsTrue(msg.HasAssemblyName);
            Assert.IsTrue(msg.HasFullTypeName);
            Assert.IsTrue(msg.HasMessage);
            Assert.IsTrue(msg.HasSource);
            Assert.IsTrue(msg.HasStackTraceString);
            Assert.IsTrue(msg.StackTraceString.Contains(GetType().FullName + ".AsThrown(Exception e)"));
            Assert.IsFalse(msg.HasRemoteStackTraceString);

            Assert.AreEqual(typeof(string).Assembly.FullName, msg.AssemblyName);
            Assert.AreEqual(typeof(InvalidOperationException).FullName, msg.FullTypeName);
            Assert.AreEqual("message", msg.Message);

            try
            {
                msg.ReThrow(RpcErrorTypeBehavior.OnlyUseLoadedAssemblies);
            }
            catch (Exception e)
            {
                Assert.AreEqual("message", e.Message);
                Assert.AreEqual(typeof(InvalidOperationException), e.GetType());
                //make sure the original stack is still there as well?
                Assert.IsTrue(e.StackTrace.Contains(GetType().FullName + ".AsThrown(Exception e)"));
                Assert.IsTrue(e.StackTrace.Contains(GetType().FullName + ".TestBehaviorFullDetails()"));
            }
        }
 protected virtual void OnException(RpcRequestHeader requestHeader, RpcResponseHeader.Builder responseHeader,
                                    Exception exception)
 {
     responseHeader.SetSuccess(false);
     responseHeader.ClearContentLength();
     responseHeader.SetException(RpcExceptionInfo.Create(exception, _exceptionDetails));
 }
        public void TestClientNoTypeResolution()
        {
            Exception e = null;

            try
            {
                RpcExceptionInfo.Create(ThrownException, RpcErrorDetailBehavior.FullDetails).ReThrow(
                    RpcErrorTypeBehavior.NoTypeResolution);
            }
            catch (Exception ex)
            {
                e = ex;
            }

            Assert.AreEqual(typeof(ApplicationException), e.GetType());
            Assert.AreEqual(ThrownException.Message, e.Message);
        }
        public void TestBehaviorNoDetails()
        {
            RpcExceptionInfo msg = RpcExceptionInfo.Create(ThrownException, RpcErrorDetailBehavior.NoDetails);

            Assert.IsFalse(msg.HasAssemblyName);
            Assert.IsFalse(msg.HasFullTypeName);
            Assert.IsFalse(msg.HasMessage);
            //basically it should be empty:
            Assert.AreEqual(new byte[0], msg.ToByteArray());

            try
            {
                msg.ReThrow(RpcErrorTypeBehavior.OnlyUseLoadedAssemblies);
            }
            catch (Exception e)
            {
                Assert.AreEqual(typeof(ApplicationException), e.GetType());
            }
        }
        public void TestBehaviorTypeOnly()
        {
            RpcExceptionInfo msg = RpcExceptionInfo.Create(ThrownException, RpcErrorDetailBehavior.TypeOnly);

            Assert.IsTrue(msg.HasAssemblyName);
            Assert.IsTrue(msg.HasFullTypeName);
            Assert.IsFalse(msg.HasMessage);
            Assert.IsFalse(msg.HasSource);
            Assert.IsFalse(msg.HasStackTraceString);
            Assert.IsFalse(msg.HasRemoteStackTraceString);

            Assert.AreEqual(typeof(string).Assembly.FullName, msg.AssemblyName);
            Assert.AreEqual(typeof(ArgumentNullException).FullName, msg.FullTypeName);

            try
            {
                msg.ReThrow(RpcErrorTypeBehavior.OnlyUseLoadedAssemblies);
            }
            catch (Exception e)
            {
                Assert.AreEqual(typeof(ArgumentNullException), e.GetType());
            }
        }