//define interface to be mocked

public interface IFake
        {

bool DoSomething(string actionname);

        }

//define the test method

        [TestMethod]

public void Test_Interface_IFake()
        {

//make a mock Object by Moq

var mo = new Mock<IFake>();

//Setup our mock object

            mo.Setup(foo => foo.DoSomething("Ping"))

            .Returns(true);

//Assert it!

            Assert.AreEqual(true, mo.Object.DoSomething("Ping"));
        }

public interface IEmailSender
        {

bool Send(string subject, string body, string email);

        }
  [TestMethod]

public void User_Can_Send_Password()
        {

var emailMock = new Mock<IEmailSender>();

            emailMock

            .Setup(sender => sender.Send(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))

            .Returns(true);

        }

  var productRepository = new Mock<IProductRepository>();

            productRepository

            .Expect(p => p.Get(It.Is<int>(id => id > 0 && id < 6)))

            .Returns(newProduct.Object);

namespace Moq
{
// Summary:
//     Options to customize the behavior of the mock.
    public enum MockBehavior
    {
// Summary:
//     Causes the mock to always throw an exception for invocations that don't have
//     a corresponding setup.
        Strict = 0,
//
// Summary:
//     Will never throw exceptions, returning default values when necessary (null
//     for reference types, zero for value types or empty enumerables and arrays).
        Loose = 1,
//
// Summary:
//     Default mock behavior, which equals Moq.MockBehavior.Loose.
        Default = 1,
    }
}

var mock = new Mock<IFake>(MockBehavior.Strict);

var factory = new MockFactory(MockBehavior.Strict) { DefaultValue = DefaultValue.Mock };

// Create a mock using the factory settings

var fooMock = factory.Create<IFake>();

// Create a mock overriding the factory settings

var barMock = factory.Create<IEmailSender>(MockBehavior.Loose);

// Verify all verifiable expectations on all mocks created through the factory

            factory.Verify();

mock.Verify(foo => foo.DoSomething("Ping"), Times.Once());

   [TestMethod]

public void Test_FindByName_GetCalled()
        {

// create some mock data

            IList<Product> products = new List<Product>

{

new Product { ProductId = 1, Name = "C# Unleashed",

            Description = "Short description here", Price = 49.99 },

new Product { ProductId = 2, Name = "ASP.Net Unleashed",

            Description = "Short description here", Price = 59.99 },

new Product { ProductId = 3, Name = "Silverlight Unleashed",

            Description = "Short description here", Price = 29.99 }

};

            Mock<IProductRepository> mock = new Mock<IProductRepository>();

//mock

//.Setup(sender => sender.FindById(It.IsAny<int>()))

//.Returns((int s) => products.Where(

//    x => x.ProductId == s).Single());

            mock.Object.FindById(1);

            mock

            .Verify(x => x.FindById(1), Times.Once());

        }
    }