public void ActWithInputAndReturnType_ActActionWithoutException_ActedInstanceReturned()
{
var arranged = new Arranged <string>("input");
var result = arranged.Act(input => 1);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted <int>));
}
public void ActWithFourInputs_ActActionWithoutException_ActActionIsCalled()
{
var arranged = new Arranged <string, int, double, decimal>("input", 1, 2.0, 3m);
var called = false;
arranged.Act((input, param1, param2, param3) => called = true);
Assert.IsTrue(called);
}
public void ActWithInput_ActActionWithoutException_ActActionIsCalled()
{
var arranged = new Arranged <string>("input");
var called = false;
arranged.Act(input => called = true);
Assert.IsTrue(called);
}
public void ActWithReturnType_ActActionWithException_ActedInstanceReturned()
{
var arranged = new Arranged();
var result = arranged.Act <int>(() => throw new IOException());
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted <int>));
}
public void ActWithFourInputs_ActActionWithoutException_ActedInstanceReturned()
{
var arranged = new Arranged <string, int, double, decimal>("input", 1, 2.0, 3m);
var result = arranged.Act((input, param1, param2, param3) => { });
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted));
}
public void Act_ActActionWithoutException_ActedInstanceReturned()
{
var arranged = new Arranged();
var result = arranged.Act(() => { });
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted));
}
public void ActWithThreeInputs_ActActionWithoutException_ActActionIsCalled()
{
var arranged = new Arranged <string, int, double>("input", 1, 2.0);
var called = false;
arranged.Act((input, param1, param2) => called = true);
Assert.IsTrue(called);
}
public void ActWithThreeInputsAndReturnType_ActActionWithoutException_ActedInstanceReturned()
{
var arranged = new Arranged <string, int, double>("input", 1, 2.0);
var result = arranged.Act((input, param1, param2) => 1);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted <int>));
}
public void ActWithTwoInputsAndReturnType_ActActionWithException_ActedInstanceReturned()
{
var arranged = new Arranged <string, int>("input", 1);
var result = arranged.Act <int>((input, parameter) => throw new IOException());
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted <int>));
}
public void ActAsync_ActActionWithoutException_ActedInstanceReturned()
{
var arranged = new Arranged();
var result = arranged.ActAsync(async() => { await DoSomethingAsync(); });
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted));
}
public void ActWithTwoInputs_ActActionWithoutException_ActActionIsCalled()
{
var arranged = new Arranged <string, int>("input", 1);
var called = false;
arranged.Act((input, parameter) => called = true);
Assert.IsTrue(called);
}
public void ActWithTwoInputs_ActActionWithoutException_ActedInstanceReturned()
{
var arranged = new Arranged <string, int>("input", 1);
var result = arranged.Act((input, parameter) => { });
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted));
}
public void Act_ActActionWithoutException_ActActionIsCalled()
{
var arranged = new Arranged();
var called = false;
arranged.Act(() => called = true);
Assert.IsTrue(called);
}
public void ActWithInput_ActActionWithException_ActedInstanceReturned()
{
var arranged = new Arranged <string>("input");
var result = arranged.Act(input => throw new IOException());
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted));
}
public void ActWithFourInputsAndReturnType_ActActionWithException_ActedInstanceReturned()
{
var arranged = new Arranged <string, int, double, decimal>("input", 1, 2.0, 3m);
var result = arranged.Act <int>((input, param1, param2, param3) => throw new IOException());
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted <int>));
}
public void ActAsyncWithThreeInputs_ActActionWithoutException_ActedInstanceReturned()
{
var arranged = new Arranged <string, int, double>("input", 1, 2.0);
var result = arranged.ActAsync(async(input, param1, param2) =>
{
await DoSomethingAsync();
});
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted));
}
public void ActWithInputAndReturnType_ActActionWithoutException_ActActionIsCalled()
{
var arranged = new Arranged <string>("input");
var called = false;
arranged.Act(input =>
{
called = true;
return(1);
});
Assert.IsTrue(called);
}
public void ActAsyncWithTwoInputs_ActActionWithoutException_ActActionIsCalled()
{
var arranged = new Arranged <string, int>("input", 1);
var called = false;
arranged.ActAsync(async(input, parameter) =>
{
await DoSomethingAsync();
called = true;
});
Assert.IsTrue(called);
}
public void ActAsyncWithTwoInputs_ActActionWithException_ActedInstanceReturned()
{
var arranged = new Arranged <string, int>("input", 1);
var result = arranged.ActAsync(async(input, parameter) =>
{
await DoSomethingAsync();
throw new IOException();
});
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted));
}
public void ActAsyncWithInputAndReturnType_ActActionWithoutException_ActedInstanceReturned()
{
var arranged = new Arranged <string>("input");
var result = arranged.ActAsync(async input =>
{
await DoSomethingAsync();
return(1);
});
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted <int>));
}
public void ActAsync_ActActionWithoutException_ActActionIsCalled()
{
var arranged = new Arranged();
var called = false;
arranged.ActAsync(async() =>
{
await DoSomethingAsync();
return(called = true);
});
Assert.IsTrue(called);
}
public void ActWithTwoInputsAndReturnType_ActActionWithException_ActActionIsCalled()
{
var arranged = new Arranged <string, int>("input", 1);
var called = false;
arranged.Act <int>((input, parameter) =>
{
called = true;
throw new IOException();
});
Assert.IsTrue(called);
}
public void ActWithReturnType_ActActionWithException_ActActionIsCalled()
{
var arranged = new Arranged();
var called = false;
arranged.Act <int>(() =>
{
called = true;
throw new IOException();
});
Assert.IsTrue(called);
}
public void ActAsyncWithFourInputs_ActActionWithoutException_ActActionIsCalled()
{
var arranged = new Arranged <string, int, double, decimal>("input", 1, 2.0, 3m);
var called = false;
arranged.ActAsync(async(input, param1, param2, param3) =>
{
await DoSomethingAsync();
return(called = true);
});
Assert.IsTrue(called);
}
public void ActWithInputAndReturnType_ActActionWithException_ActActionIsCalled()
{
var arranged = new Arranged <string>("input");
var called = false;
arranged.Act <int>(input =>
{
called = true;
throw new IOException();
});
Assert.IsTrue(called);
}
public void ActWithReturnType_ActActionWithoutException_ActActionIsCalled()
{
var arranged = new Arranged();
var called = false;
arranged.Act(() =>
{
called = true;
return(1);
});
Assert.IsTrue(called);
}
public void ActAsyncWithReturnType_ActActionWithException_ActedInstanceReturned()
{
var arranged = new Arranged();
var result = arranged.ActAsync <int>(async() =>
{
await DoSomethingAsync();
throw new IOException();
});
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted <int>));
}
public void ActAsyncWithFourInputsAndReturnType_ActActionWithoutException_ActedInstanceReturned()
{
var arranged = new Arranged <string, int, double, decimal>("input", 1, 2.0, 3m);
var result = arranged.ActAsync(async(input, param1, param2, param3) =>
{
await DoSomethingAsync();
return(1);
});
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Acted <int>));
}
public void ActWithFourInputsAndReturnType_ActActionWithException_ActActionIsCalled()
{
var arranged = new Arranged <string, int, double, decimal>("input", 1, 2.0, 3m);
var called = false;
arranged.Act <int>((input, param1, param2, param3) =>
{
called = true;
throw new IOException();
});
Assert.IsTrue(called);
}
public void ActAsync_ActActionWithException_ActActionIsCalled()
{
var arranged = new Arranged();
var called = false;
arranged.ActAsync(async() =>
{
await DoSomethingAsync();
called = true;
throw new IOException();
});
Assert.IsTrue(called);
}
