Added CallBase support

src/Moq/Moq.Tests/CallBaseTests.cs

@@ -0,0 +1,78 @@
+using System;
+using System.ComponentModel;
+using Xunit;
+using Moq.Sdk;
+using static Moq.Syntax;
+using Sample;
+
+namespace Moq.Tests
+{
+    public class CallBaseTests
+    {
+        [Fact]
+        public void callbase1()
+        {
+            var mock = Mock.Of<Calculator>();
+
+            mock.TurnOn();
+
+            Assert.False(mock.TurnOnCalled);
+        }
+
+        [Fact]
+        public void callbase2()
+        {
+            var mock = Mock.Of<Calculator>().CallBase();
+
+            mock.TurnOn();
+
+            Assert.True(mock.TurnOnCalled);
+        }
+
+        [Fact]
+        public void callbase3()
+        {
+            var mock = Mock.Of<Calculator>();
+
+            mock.Setup(x => x.TurnOn()).CallBase();
+
+            mock.TurnOn();
+
+            Assert.True(mock.TurnOnCalled);
+        }
+
+        [Fact]
+        public void callbase4()
+        {
+            var mock = Mock.Of<Calculator>(MockBehavior.Strict).CallBase();
+
+            Assert.Throws<StrictMockException>(() => mock.TurnOn());
+        }
+
+        [Fact]
+        public void callbase5()
+        {
+            var mock = Mock.Of<Calculator>(MockBehavior.Strict).CallBase();
+
+            mock.Setup(x => x.TurnOn());
+
+            mock.TurnOn();
+
+            Assert.True(mock.TurnOnCalled);
+            Assert.Throws<StrictMockException>(() => mock.Recall(""));
+        }
+
+        [Fact]
+        public void callbase6()
+        {
+            var mock = Mock.Of<Calculator>(MockBehavior.Strict);
+
+            mock.Setup(x => x.TurnOn()).CallBase();
+
+            mock.TurnOn();
+
+            Assert.True(mock.TurnOnCalled);
+            Assert.Throws<StrictMockException>(() => mock.Recall(""));
+        }
+    }
+}

src/Moq/Moq.Tests/Mocks/CalculatorMock.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Moq.Sdk;
+using Sample;
+using Stunts;
+
+namespace Mocks
+{
+    public partial class CalculatorMock : Calculator, IMocked, IStunt
+    {
+        BehaviorPipeline pipeline = new BehaviorPipeline();
+
+        public ObservableCollection<IStuntBehavior> Behaviors => pipeline.Behaviors;
+
+        public override event EventHandler TurnedOn
+        {
+            add => pipeline.Execute(new MethodInvocation(this, MethodBase.GetCurrentMethod(), value), (m, n) => { base.TurnedOn += value; return m.CreateValueReturn(null, value); });
+            remove => pipeline.Execute(new MethodInvocation(this, MethodBase.GetCurrentMethod(), value), (m, n) => { base.TurnedOn -= value; return m.CreateValueReturn(null, value); });
+        }
+
+        public override CalculatorMode Mode
+        {
+            get => pipeline.Execute<CalculatorMode>(new MethodInvocation(this, MethodBase.GetCurrentMethod()), (m, n) => m.CreateValueReturn(base.Mode));
+            set => pipeline.Invoke(new MethodInvocation(this, MethodBase.GetCurrentMethod(), value), (m, n) => { base.Mode = value; return m.CreateValueReturn(null, value); });
+        }
+
+        public override int? this[string name]
+        {
+            get => pipeline.Execute<int?>(new MethodInvocation(this, MethodBase.GetCurrentMethod()), (m, n) => m.CreateValueReturn(base[name]));
+            set => pipeline.Execute(new MethodInvocation(this, MethodBase.GetCurrentMethod(), name, value), (m, n) => { base[name] = value; return m.CreateValueReturn(null, value); });
+        }
+
+        public override bool IsOn => pipeline.Execute<bool>(new MethodInvocation(this, MethodBase.GetCurrentMethod()), (m, n) => m.CreateValueReturn(base.IsOn));
+
+        public override int Add(int x, int y) =>
+            pipeline.Execute<int>(new MethodInvocation(this, MethodBase.GetCurrentMethod(), x, y), (m, n) => m.CreateValueReturn(base.Add(x, y), x, y));
+
+        public override int Add(int x, int y, int z) =>
+            pipeline.Execute<int>(new MethodInvocation(this, MethodBase.GetCurrentMethod(), x, y, z), (m, n) => m.CreateValueReturn(base.Add(x, y, z), x, y, z));
+
+        public override bool TryAdd(ref int x, ref int y, out int z)
+        {
+            z = default(int);
+            var local_x = x;
+            var local_y = y;
+            var local_z = z;
+
+            var result = pipeline.Invoke(new MethodInvocation(this, MethodBase.GetCurrentMethod(), x, y, z),
+                (m, n) => m.CreateValueReturn(base.TryAdd(ref local_x, ref local_y, out local_z), local_x, local_y, local_z), true);
+
+            x = (int)result.Outputs["x"];
+            y = (int)result.Outputs["y"];
+            z = (int)result.Outputs["z"];
+
+            return (bool)result.ReturnValue;
+        }
+
+        public override void TurnOn() =>
+            pipeline.Execute(new MethodInvocation(this, MethodBase.GetCurrentMethod()), (m, n) => { base.TurnOn(); return m.CreateValueReturn(null); });
+
+
+        public override void Store(string name, int value) =>
+            pipeline.Execute(new MethodInvocation(this, MethodBase.GetCurrentMethod(), name, value), (m, n) => { base.Store(name, value); return m.CreateValueReturn(null, name, value); });
+
+        public override int? Recall(string name) =>
+            pipeline.Execute<int?>(new MethodInvocation(this, MethodBase.GetCurrentMethod(), name), (m, n) => m.CreateValueReturn(base.Recall(name), name));
+
+
+        public override void Clear(string name) =>
+            pipeline.Execute(new MethodInvocation(this, MethodBase.GetCurrentMethod(), name), (m, n) => { base.Clear(name); return m.CreateValueReturn(null, name); });
+
+
+        public override ICalculatorMemory Memory
+        {
+            get => pipeline.Execute<ICalculatorMemory>(new MethodInvocation(this, MethodBase.GetCurrentMethod()), (m, n) => m.CreateValueReturn(base.Memory));
+        }
+
+        #region IMocked
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        IMock mock;
+
+        [DebuggerDisplay("Invocations = {Invocations.Count}", Name = nameof(IMocked.Mock))]
+        [DebuggerBrowsable(DebuggerBrowsableState.Collapsed)]
+        [CompilerGenerated]
+        IMock IMocked.Mock => LazyInitializer.EnsureInitialized(ref mock, () => new DefaultMock(this));
+        #endregion
+    }
+}

src/Moq/Moq/CallBaseBehavior.cs

@@ -0,0 +1,40 @@
+using System;
+using Stunts;
+using Moq.Sdk;
+using System.Linq;
+using System.ComponentModel;
+using System.Diagnostics;
+
+namespace Moq
+{
+    /// <summary>
+    /// A custom behavior to enable calls to the base member virtual implementation
+    /// <see cref="CallBaseExtension"/> method calls.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public class CallBaseBehavior : IStuntBehavior
+    {
+        /// <inheritdoc />
+        public bool AppliesTo(IMethodInvocation invocation) => true;
+
+        /// <inheritdoc />
+        public IMethodReturn Execute(IMethodInvocation invocation, GetNextBehavior next)
+        {
+            // Check if CallBase is configured at the Mock or Invocation level
+            var shouldCallBase = invocation.Target.AsMoq().CallBase || invocation.Context.ContainsKey(nameof(IMoq.CallBase));
+
+            if (shouldCallBase)
+            {
+                // Skip the default value to force the base target member is executed
+                invocation.SkipBehaviors.Add(typeof(DefaultValueBehavior));
+
+                // If there is a matching setup for the current invocation, skip the strict 
+                // behavior because CallBase should be called instead
+                if (invocation.Target.AsMock().Behaviors.OfType<IMockBehaviorPipeline>().Any(x => x.AppliesTo(invocation)))
+                    invocation.SkipBehaviors.Add(typeof(StrictMockBehavior));
+            }
+
+            return next().Invoke(invocation, next);
+        }
+    }
+}

src/Moq/Moq/CallBaseExtension.cs

@@ -0,0 +1,40 @@
+using Moq.Sdk;
+using System.ComponentModel;
+using System;
+
+namespace Moq
+{
+    /// <summary>
+    /// Extensions for calling base member virtual implementation
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public static class CallBaseExtension
+    {
+        /// <summary>
+        /// Specifies to call the base member virtual implementation
+        /// </summary>
+        public static T CallBase<T>(this T target)
+        {
+            if (target is IMocked mocked && mocked != null)
+            {
+                // Configure CallBase at the Mock level
+                mocked.AsMoq().CallBase = true;
+            }
+            else if (MockContext.CurrentInvocation != null)
+            {
+                // Configure CallBase at the invocation level
+                MockContext.CurrentInvocation.Target.AsMock().GetPipeline(MockContext.CurrentSetup).Behaviors.Add(new DelegateMockBehavior(
+                     (m, i, next) =>
+                     {
+                         // set CallBase
+                         i.Context[nameof(IMoq.CallBase)] = true;
+
+                         return next().Invoke(i.Target.AsMock(), i, next);
+
+                     }, nameof(IMoq.CallBase)));
+            }
+
+            return target;
+        }
+    }
+}

src/Moq/Moq/ConfigurePipelineBehavior.cs

@@ -28,6 +28,11 @@ public IMethodReturn Execute(IMethodInvocation invocation, GetNextBehavior next)
                 invocation.SkipBehaviors.Add(typeof(StrictMockBehavior));
             }
 
+            // Ensure the Mock pipeline is always created for the matching setup
+            // We need this to skip the StrictBehavior in the CallBaseBehavior
+            if (SetupScope.IsActive)
+                invocation.Target.AsMock().GetPipeline(MockContext.CurrentSetup);
+
             return next().Invoke(invocation, next);
         }
     }

src/Moq/Moq/IMoq.cs

@@ -17,5 +17,11 @@ public interface IMoq : IMock
         /// Only available for <see cref="MockBehavior.Loose"/> mocks.
         /// </summary>
         DefaultValueProvider DefaultValue { get; set; }
+
+        /// <summary>
+		/// Whether the base member virtual implementation will be called for mocked classes if no setup is matched.
+		/// Defaults to <see langword="false"/>.
+        /// </summary>
+        bool CallBase { get; set; }
     }
-}
+}

src/Moq/Moq/Legacy/Mock`1.cs

@@ -56,6 +56,14 @@ public Mock(MockBehavior behavior, params object[] args) : this(Assembly.GetCall
         [EditorBrowsable(EditorBrowsableState.Never)]
         public T Object => target;
 
+        /// <summary>Supports the legacy API.</summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public bool CallBase
+        {
+            get => mock.AsMoq().CallBase;
+            set => mock.AsMoq().CallBase = value;
+        }
+
         /// <summary>Supports the legacy API.</summary>
         [EditorBrowsable(EditorBrowsableState.Never)]
         public Mock<TInterface> As<TInterface>()

src/Moq/Moq/MockInitializer.cs

@@ -30,13 +30,14 @@ public static void Initialize(this IMocked mocked, MockBehavior behavior)
             mocked.AsMoq().Behavior = behavior;
 
             mocked.Mock.Behaviors.Add(new SetupScopeBehavior());
-            mocked.Mock.Behaviors.Add(new ConfigurePipelineBehavior());
             mocked.Mock.Behaviors.Add(new MockContextBehavior());
+            mocked.Mock.Behaviors.Add(new ConfigurePipelineBehavior());
             mocked.Mock.Behaviors.Add(new MockRecordingBehavior());
             mocked.Mock.Behaviors.Add(new EventBehavior());
             mocked.Mock.Behaviors.Add(new PropertyBehavior { SetterRequiresSetup = behavior == MockBehavior.Strict });
             mocked.Mock.Behaviors.Add(new DefaultEqualityBehavior());
             mocked.Mock.Behaviors.Add(new RecursiveMockBehavior());
+            mocked.Mock.Behaviors.Add(new CallBaseBehavior());
 
             // Dynamically configured by the ConfigurePipelineBehavior.
             mocked.Mock.Behaviors.Add(new StrictMockBehavior());

src/Moq/Moq/Moq`1.cs

@@ -5,6 +5,8 @@
 
 namespace Moq
 {
+
+
     /// <summary>
     /// Provides the Moq specific configurations on top of an <see cref="Sdk.IMock{T}"/> that 
     /// the Moq API provides beyond the SDK.
@@ -51,5 +53,12 @@ public DefaultValueProvider DefaultValue
                 State.Set(value);
             }
         }
+
+        /// <inheritdoc />
+        public bool CallBase
+        {
+            get => State.GetOrAdd(nameof(IMoq) + "." + nameof(CallBase), () => false);
+            set => State.Set(nameof(IMoq) + "." + nameof(CallBase), value);
+        }
     }
-}
+}

src/Moq/Moq/SetupScopeBehavior.cs

@@ -18,6 +18,7 @@ internal class SetupScopeBehavior : IStuntBehavior
             typeof(DefaultValueBehavior), 
             typeof(MockContextBehavior),
             typeof(RecursiveMockBehavior),
+            typeof(ConfigurePipelineBehavior)
         };
 
         /// <summary>

src/Samples/Sample/Calculator.cs

@@ -10,6 +10,8 @@ public class Calculator : ICalculator, IDisposable
 
         public virtual event EventHandler TurnedOn;
 
+        public bool TurnOnCalled { get; set; }
+
         public virtual bool IsOn { get; private set; }
 
         public virtual CalculatorMode Mode { get; set; }
@@ -22,6 +24,7 @@ public virtual void TurnOn()
         {
             TurnedOn?.Invoke(this, EventArgs.Empty);
             IsOn = true;
+            TurnOnCalled = true;
         }
 
         public virtual int? this[string name]

src/Samples/Sample/CalculatorClassStunt.cs

@@ -29,6 +29,8 @@ public override int? this[string name]
             set => pipeline.Execute(new MethodInvocation(this, MethodBase.GetCurrentMethod(), name, value), (m, n) => { base[name] = value; return m.CreateValueReturn(null, value); });
         }
 
+        public override bool IsOn => pipeline.Execute<bool>(new MethodInvocation(this, MethodBase.GetCurrentMethod()), (m, n) => m.CreateValueReturn(base.IsOn));
+
         public override int Add(int x, int y) => 
             pipeline.Execute<int>(new MethodInvocation(this, MethodBase.GetCurrentMethod(), x, y), (m, n) => m.CreateValueReturn(base.Add(x, y), x, y));
 
@@ -55,6 +57,7 @@ public override bool TryAdd(ref int x, ref int y, out int z)
         public override void TurnOn() =>
             pipeline.Execute(new MethodInvocation(this, MethodBase.GetCurrentMethod()), (m, n) => { base.TurnOn(); return m.CreateValueReturn(null); });
 
+
         public override void Store(string name, int value) =>
             pipeline.Execute(new MethodInvocation(this, MethodBase.GetCurrentMethod(), name, value), (m, n) => { base.Store(name, value); return m.CreateValueReturn(null, name, value); });