patrik-hagne

public static class dlkfjslkjd
{
    public static IAnyCallConfigurationWithNoReturnTypeSpecified AnyCall<T>(this IFakeOptionsBuilder<T> options)
    {
        var result = new Callback();

        options.OnFakeCreated(x => result.Apply(A.CallTo(x)));

        return result;
    }

patrik-hagne

// This example illustrates why having FakeItEasy default to comparing sequence equivalence for
// enumerable types would be non intuitive.

// In this example the current implementation of FakeItEasy argument constraints would make the
// assertion (MustHaveHappened) fail, which is correct. An implementation where sequence equivalence
// would be used for the constraint the assertion would incorrectly pass.

class Program
{
    public interface IPersonRepository

patrik-hagne

        [Fact]
        public void Should_dispose_request_when_being_disposed()
        {
            // Given
            var request = A.Fake<Request>(x => x.WithArgumentsForConstructor(new[] {"GET", "/", "http"}));
            this.context.Request = request;

            // When
            this.context.Dispose();

patrik-hagne

//console = undefined;
(function(undefined) {
	var log = (function() {
		var inner = function(value) {
			if (console != undefined && console.log != undefined) {
				inner = function(value) {
					console.log(value);
				};
			} else {
				inner = function(value) {

patrik-hagne

public class Foo
{
    public void DoWhatever()
    {
        var user = this.FetchUserFromRepository("userid");
        this.DoSomethingWithTheUser(user);
    }

    protected virtual object FetchUserFromRepository(string userid)
    {

patrik-hagne

public interface IRobot
{
    string Name { get; set; }
}

public class RoboCop
    : IRobot
{
    private readonly IRobot robot;

patrik-hagne

Fake.GetCalls(_log).
    Single(call => call.Method.Name == "set_Offset").
    GetArgument<TimeSpan>(0).
    Should().Equal(newOffset);

patrik-hagne

// This example illustrates why having FakeItEasy default to comparing sequence equivalence for
// enumerable types would be non intuitive.

// In this example the current implementation of FakeItEasy argument constraints would make the
// assertion (MustHaveHappened) fail, which is correct. An implementation where sequence equivalence
// would be used for the constraint the assertion would incorrectly pass.

class Program
{
    public interface IPersonRepository