public void String_Default_ReturnsString()
{
MockObject mock = new MockObject();
var actual = _target.String(GetStubs(mock));
Assert.AreEqual(MockObject.TO_STRING_MESSAGE, actual.ToObject());
Assert.IsTrue(mock.ToStringWasExecuted);
}
public void ValidateTest()
{
MockObject pv_objInstance = new MockObject();
PropertyInfo pv_objPropertyInfo = typeof(MockObject).GetProperty("MockProperty");
PaytonByrd_ProcessConfigurationTests.PaytonByrd_ProcessConfiguration_ProcessParameterAttributeAccessor.Validate(pv_objInstance, pv_objPropertyInfo);
}
public void TestThatShortestPathIsCalculatedCorrectly()
{
mock = new MockObject();
calculator = new RouteCalculator(mock.mockObject);
testVertex = calculator.FindShortestPath(mock.mockObject[0], mock.mockObject[2], 0);
Assert.IsTrue(testVertex.GoldenNumber == 6);
}
private void IsEqual_RefObjects_ThrowsException()
{
var objA = new MockObject();
var objB = new MockObject();
Assert.ThatThrowsException(() => { Assert.IsEqual(objA, objB); },
typeof(Exception));
}
public void Get_method_by_attribute()
{
var target = new MockObject();
var pair = ReflectionHelper.RetrieveMethod <MockAttribute>(target);
pair.Should().NotBeNull();
pair.Left.Name.Should().Be("DoNothing");
}
public void ThenTest()
{
MockObject mockObject = new MockObject {
ID = 1, Touched = false
};
Assert.True(mockObject.Then(mo => mo.Touched = true).Touched);
}
public void GetClassOnMockObject()
{
IObject obj = new MockObject();
IClass cls = Utilities.GetClass(obj);
Assert.IsNotNull(cls);
Assert.IsInstanceOfType(cls, typeof(MockClass));
}
public void ShouldCallBeforeDisposeOnDisposing()
{
var mockCheckExecution = new Mock <ICheckExecution>();
using (var mockObject = new MockObject(mockCheckExecution.Object))
{
}
mockCheckExecution.Verify(m => m.Executed(), Times.Once);
}
public void Logger_OnTimeoutOccured_LogShouldBeCalledOnce( )
{
var logger = Substitute.For <ILogger>( );
var mockObj = new MockObject( );
CreateTimeoutChecker(mockObj, logger);
Thread.Sleep(DelayTime);
logger.Received( ).Log(Arg.Any <LogModel>( ));
}
public void CreateInstanceBuildUpIsCalled()
{
MockReturnExistingPlanBuilderStrategy mockPlanBuilderStrategy = new MockReturnExistingPlanBuilderStrategy();
MockBuilderContext ctx = BuildContext(mockPlanBuilderStrategy);
MockObject i1 = (MockObject)ctx.HeadOfChain.BuildUp(ctx, typeof(MockObject), null, null);
Assert.IsTrue(mockPlanBuilderStrategy.BuildUpCalled);
}
public void MockObject_StopCheckingCalledBeforeTimeout_ShouldNotBeModified( )
{
var mockObj = new MockObject( );
var checker = CreateTimeoutChecker(mockObj, null);
checker.StopChecking( );
Thread.Sleep(DelayTime);
mockObj.Result.ShouldBe(OperatingString);
}
public void WhenNoConstructorChooserPolicyDefaultChooserIsUsed()
{
PolicyList policies = new PolicyList();
MockBuilderContext ctx = BuildContext(policies);
MockObject mockInstance = (MockObject) ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), null, null);
Assert.IsTrue(mockInstance.DefaultConstructorCalled);
}
public void UnRegisterObjectTest()
{
Mediator.Mediator target = Mediator.Mediator.Instance;
MockObject m = new MockObject();
Assert.AreEqual(true, target.IsRegistered(m));
target.UnRegisterObject(m);
Assert.AreEqual(false, target.IsRegistered(m));
Debug.WriteLine((char)1060);
}
public void StateIsAssignedMatchingType()
{
workItem.State["stringValue1"] = "value1";
workItem.State["intValue1"] = 1;
MockObject target = workItem.Items.AddNew <MockObject>();
Assert.AreEqual("value1", target.StringProp);
Assert.AreEqual(1, target.IntProp);
}
public void TestThatItTakeTheExpectedWay()
{
mock = new MockObject();
calculator = new RouteCalculator(mock.mockObject);
testVertex = calculator.FindShortestPath(mock.mockObject[0], mock.mockObject[4], 0);
Assert.IsTrue(testVertex.ParentVertex == "B");
Assert.IsTrue(testVertex.VertexName == "E");
Assert.AreEqual(testVertex.GoldenNumber, 5);
}
public void SetVNetsThatDoExist()
{
List <TrackingResult> trackingIds = null;
VNetParameter vNetDetails = new VNetParameter()
{
VnetAddressSpaces = new List <string>()
{
"10.0.0.0/16"
},
LocalAddressSpaces = new List <string>()
{
"11.0.0.0/16"
},
DnsServers = new List <string>()
{
"11.0.0.10"
},
VpnAddress = "13.0.0.1"
};
int countOfAddedVNets = 0;
SetAzureRemoteAppVNet mockCmdlet = SetUpTestCommon <SetAzureRemoteAppVNet>();
// Required parameters for this test
mockCmdlet.VNetName = "vNetTest1";
mockCmdlet.VirtualNetworkAddressSpace = vNetDetails.VnetAddressSpaces.ToArray();
mockCmdlet.LocalNetworkAddressSpace = vNetDetails.LocalAddressSpaces.ToArray();
mockCmdlet.DnsServerIpAddress = vNetDetails.DnsServers.ToArray();
mockCmdlet.VpnDeviceIpAddress = vNetDetails.VpnAddress;
// Setup the environment for testing this cmdlet
countOfAddedVNets = MockObject.SetUpDefaultRemoteAppAddVNet(remoteAppManagementClientMock, vNetDetails);
mockCmdlet.ResetPipelines();
Log("Calling Set-AzureRemoteAppVNet which should have {0} VNets", countOfAddedVNets);
mockCmdlet.ExecuteCmdlet();
if (mockCmdlet.runTime().ErrorStream.Count != 0)
{
Assert.True(false,
String.Format("Set-AzureRemoteAppVNet returned the following error {0}",
mockCmdlet.runTime().ErrorStream[0].Exception.Message
)
);
}
trackingIds = MockObject.ConvertList <TrackingResult>(mockCmdlet.runTime().OutputPipeline);
Assert.NotNull(trackingIds);
Assert.True(MockObject.HasExpectedResults <TrackingResult>(trackingIds, MockObject.ContainsExpectedTrackingId),
"The actual result does not match the expected."
);
Log("The test for Set-AzureRemoteAppVNet completed successfully");
}
public void ShouldNotCallBeforeDisposeOnFinalize()
{
var mockCheckExecution = new Mock <ICheckExecution>();
var mockObject = new MockObject(mockCheckExecution.Object);
Assert.NotNull(mockObject);
mockObject = null;
GC.Collect();
GC.WaitForPendingFinalizers();
mockCheckExecution.Verify(m => m.Executed(), Times.Never);
}
public void CreatingASingletonTwiceReturnsSameInstance()
{
MockBuilderContext ctx = BuildContext();
ctx.Policies.Set <ISingletonPolicy>(new SingletonPolicy(true), typeof(MockObject), null);
MockObject i1 = (MockObject)ctx.HeadOfChain.BuildUp(ctx, typeof(MockObject), null, null);
MockObject i2 = (MockObject)ctx.HeadOfChain.BuildUp(ctx, typeof(MockObject), null, null);
Assert.AreSame(i1, i2);
}
public void CreateInstanceCallCreateInstance()
{
PolicyList policies = new PolicyList();
policies.SetDefault<IConstructorChooserPolicy>(new MockReturnNullConstructor());
MockBuilderContext ctx = BuildContext(policies);
MockObject mockInstance = (MockObject) ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), null, null);
Assert.IsTrue(mockInstance.DefaultConstructorCalled);
}
public void BuildUpExistingInstanceBuildUpIsCalled()
{
MockReturnExistingPlanBuilderStrategy mockPlanBuilderStrategy = new MockReturnExistingPlanBuilderStrategy();
MockBuilderContext ctx = BuildContext(mockPlanBuilderStrategy);
MockObject expectedObject = new MockObject();
MockObject i1 = (MockObject) ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), expectedObject, null);
Assert.IsTrue(mockPlanBuilderStrategy.BuildUpCalled);
Assert.AreSame(expectedObject, i1);
}
public void BuildUpExistingInstanceBuildUpIsCalled()
{
MockReturnExistingPlanBuilderStrategy mockPlanBuilderStrategy = new MockReturnExistingPlanBuilderStrategy();
MockBuilderContext ctx = BuildContext(mockPlanBuilderStrategy);
MockObject expectedObject = new MockObject();
MockObject i1 = (MockObject)ctx.HeadOfChain.BuildUp(ctx, typeof(MockObject), expectedObject, null);
Assert.IsTrue(mockPlanBuilderStrategy.BuildUpCalled);
Assert.AreSame(expectedObject, i1);
}
public void Serialize()
{
MockObject mo = new MockObject();
mo.Guid = Guid.NewGuid();
mo.Name = "Test";
mo.Description = "Description";
string json = JSONHelper.GetJson(mo);
Assert.IsNotNull(json);
}
public void when_json_is_valid()
{
var json = "{\"number\":123,\"string_property\":\"456\"}";
var value = new MockObject {
number = 123, string_property = "456"
};
var mockObject = json.JsonToObject <MockObject>();
Assert.Equal(value.number, mockObject.number);
Assert.Equal(value.string_property, mockObject.string_property);
}
public void CanCreateSingletonObjectWithDefaultObjectBuilder()
{
Builder builder = new Builder();
Locator locator = CreateLocator();
builder.Policies.Set <ISingletonPolicy>(new SingletonPolicy(true), typeof(MockObject), "foo");
MockObject obj1 = builder.BuildUp <MockObject>(locator, "foo", null);
MockObject obj2 = builder.BuildUp <MockObject>(locator, "foo", null);
Assert.AreSame(obj1, obj2);
}
public void GetResourceAsClassTest()
{
var input = new MockObject {
Id = "1", Value = "Mock"
};
var response = ApiResponse.OK().WithResource(input, input.Id).AsItemResponse();
var output = response.GetResourceAs <MockObject>();
Assert.Equal(input.Id, output.Id);
}
public void StrategyDoesNothingWithNoPolicy()
{
MethodExecutionStrategy strategy = new MethodExecutionStrategy();
MockBuilderContext ctx = new MockBuilderContext();
MockObject obj = new MockObject();
ctx.InnerChain.Add(strategy);
ctx.HeadOfChain.BuildUp(ctx, typeof(MockObject), obj, null);
Assert.IsFalse(obj.ParameterlessWasCalled);
}
public void TestItemGetOrSet()
{
using (var map = new MemoryMapStream())
{
var dictionary = new Dictionary <string, string>(map);
dictionary["Ben"] = "Abelshausen";
Assert.Catch <System.Collections.Generic.KeyNotFoundException>(() =>
{
var t = dictionary["Ben2"];
});
Assert.AreEqual("Abelshausen", dictionary["Ben"]);
}
MockObject.RegisterAccessorCreateFunc();
using (var map = new MemoryMapStream())
{
var dictionary = new Dictionary <MockObject, string>(map);
dictionary[new MockObject("Ben")] = "Abelshausen";
dictionary[new MockObject("Ben1")] = "Abelshausen1";
dictionary[new MockObject("Ben2")] = "Abelshausen2";
dictionary[new MockObject("Ben3")] = "Abelshausen3";
dictionary[new MockObject("Ben4")] = "Abelshausen4";
dictionary[new MockObject("Ben5")] = "Abelshausen5";
Assert.Catch <System.Collections.Generic.KeyNotFoundException>(() =>
{
var t = dictionary[new MockObject("Ben6")];
});
Assert.AreEqual("Abelshausen", dictionary[new MockObject("Ben")]);
Assert.AreEqual("Abelshausen1", dictionary[new MockObject("Ben1")]);
Assert.AreEqual("Abelshausen2", dictionary[new MockObject("Ben2")]);
Assert.AreEqual("Abelshausen3", dictionary[new MockObject("Ben3")]);
Assert.AreEqual("Abelshausen4", dictionary[new MockObject("Ben4")]);
Assert.AreEqual("Abelshausen5", dictionary[new MockObject("Ben5")]);
dictionary[new MockObject("Ben")] = "Abelshausen1";
dictionary[new MockObject("Ben1")] = "Abelshausen11";
dictionary[new MockObject("Ben2")] = "Abelshausen12";
dictionary[new MockObject("Ben3")] = "Abelshausen13";
Assert.AreEqual("Abelshausen1", dictionary[new MockObject("Ben")]);
Assert.AreEqual("Abelshausen11", dictionary[new MockObject("Ben1")]);
Assert.AreEqual("Abelshausen12", dictionary[new MockObject("Ben2")]);
Assert.AreEqual("Abelshausen13", dictionary[new MockObject("Ben3")]);
Assert.AreEqual("Abelshausen4", dictionary[new MockObject("Ben4")]);
Assert.AreEqual("Abelshausen5", dictionary[new MockObject("Ben5")]);
}
}
public void AppendTimeChannelData(MockObject @object, DateTime index, double value)
{
CheckLocked();
var channel = @object as MockChannel;
if (channel == null)
{
return;
}
channel.AppendTimeData(index, value, StoreLastWrite);
}
public void Should_not_return_taskcategory_when_taskCategoryId_2_not_exist()
{
//Arrange
TaskCategory taskCategory = null;
MockObject.Setup(m => m.FindById(2)).Returns(taskCategory);
//act
OperationResult <TaskCategory> actualResult = TaskCategoryBusinessLogic.GetTaskCategoryById(2);
//assert
Assert.AreEqual("TaskCategory Not Found", actualResult.Message);
}
public override ChannelSubscriptionInfo GetContext(MockObject @object)
{
ChannelSubscriptionInfo info;
if (@object != null && ChannelSubscriptionsByChannelUuid.TryGetValue(@object.Uuid, out info))
{
return(info);
}
else
{
return(null);
}
}
public void UnRegisterTest1()
{
Mediator.Mediator target = Mediator.Mediator.Instance;
MockObject m = new MockObject();
Assert.AreEqual(true, target.IsRegistered(m));
target.NotifyColleagues(1, 5);
Assert.AreEqual(5, m.Index);
target.UnRegister(m._Action);
target.NotifyColleagues(1, 10);
Assert.AreEqual(5, m.Index);
}
public void AddTest()
{
var add = new MockObject();
for (int i = 0; i < 10; i++)
{
_target.Add(add);
}
int expected = 10;
int actual;
actual = _target.Add(add);
Assert.AreEqual(expected, actual);
}
public void IncompatibleTypesThrows()
{
MethodExecutionStrategy strategy = new MethodExecutionStrategy();
MockBuilderContext ctx = new MockBuilderContext();
MockObject obj = new MockObject();
ctx.InnerChain.Add(strategy);
MethodPolicy policy = new MethodPolicy();
MethodInfo mi = typeof(MockObject).GetMethod("IntMethod");
policy.Methods.Add("IntMethod", new MethodCallInfo( mi, new ValueParameter<string>(String.Empty)));
ctx.Policies.Set<IMethodPolicy>(policy, typeof(MockObject), null);
ctx.HeadOfChain.BuildUp(ctx, typeof(MockObject), obj, null);
}
public void CreatingInstanceCreatedBuildPlanUsingPlanBuilderPolicy()
{
MockBuilderContext ctx = BuildContext();
MockObject expectedObject = new MockObject();
IBuildPlan buildPlan = new MockBuildPlan(expectedObject);
IPlanBuilderPolicy planBuilderPolicy = new MockPlanBuilderPolicy(buildPlan);
ctx.Policies.SetDefault<IPlanBuilderPolicy>(planBuilderPolicy);
MockObject i1 = (MockObject) ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), null, null);
Assert.IsNotNull(i1);
Assert.AreSame(expectedObject, i1);
}
public void CreatingInstanceGetsProperBuildPlanUsingBuildPlanPolicy()
{
MockBuilderContext ctx = BuildContext();
MockObject expectedObject = new MockObject();
IBuildPlan buildPlan = new MockBuildPlan(expectedObject);
IBuildPlanPolicy buildPlanPolicy = new BuildPlanPolicy();
buildPlanPolicy.Set(typeof (MockObject), buildPlan);
ctx.Policies.SetDefault<IBuildPlanPolicy>(buildPlanPolicy);
MockObject i1 = (MockObject) ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), null, null);
Assert.IsNotNull(i1);
Assert.AreSame(expectedObject, i1);
}
public void StrategyDoesWorkBasedOnConcreteTypeInsteadOfPassedType()
{
MethodExecutionStrategy strategy = new MethodExecutionStrategy();
MockBuilderContext ctx = new MockBuilderContext();
MockObject obj = new MockObject();
ctx.InnerChain.Add(strategy);
MethodPolicy policy = new MethodPolicy();
policy.Methods.Add("ParameterlessMethod", new MethodCallInfo("ParameterlessMethod"));
ctx.Policies.Set<IMethodPolicy>(policy, typeof(MockObject), null);
ctx.HeadOfChain.BuildUp(ctx, typeof (object), obj, null);
Assert.IsTrue(obj.ParameterlessWasCalled);
}
public void StrategyCallsMethodWithDirectValues()
{
MethodExecutionStrategy strategy = new MethodExecutionStrategy();
MockBuilderContext ctx = new MockBuilderContext();
MockObject obj = new MockObject();
ctx.InnerChain.Add(strategy);
MethodPolicy policy = new MethodPolicy();
policy.Methods.Add("IntMethod", new MethodCallInfo("IntMethod", 32));
ctx.Policies.Set<IMethodPolicy>(policy, typeof (MockObject), null);
ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), obj, null);
Assert.AreEqual(32, obj.IntValue);
}
public void CanCallMultiParameterMethods()
{
MethodExecutionStrategy strategy = new MethodExecutionStrategy();
MockBuilderContext ctx = new MockBuilderContext();
MockObject obj = new MockObject();
ctx.InnerChain.Add(strategy);
MethodPolicy policy = new MethodPolicy();
policy.Methods.Add("MultiParamMethod", new MethodCallInfo("MultiParamMethod", 1.0, "foo"));
ctx.Policies.Set<IMethodPolicy>(policy, typeof (MockObject), null);
ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), obj, null);
Assert.AreEqual(1.0, obj.MultiDouble);
Assert.AreEqual("foo", obj.MultiString);
}
public void ConstructorFuncOfTOfint_should_use_default_Equals_and_specified_GetHashCode()
{
// Arrange
var getHashCodeCalled = false;
var equalsCalled = false;
var mock = new MockObject();
mock.GetHashCodeProvider = () => { getHashCodeCalled = true; return 0; };
mock.EqualsProvider = obj => { equalsCalled = true; return true; };
// Act
var comparer = new LambdaEqualityComparer<MockObject>(_ => 0);
var hashCode = comparer.GetHashCode(mock);
var isEqual = comparer.Equals(mock, mock);
// Assert
Assert.IsFalse(getHashCodeCalled);
Assert.IsTrue(equalsCalled);
Assert.AreEqual(0, hashCode);
Assert.IsTrue(isEqual);
}
public static MappedAccessor<MockObject> CreateAccessor(MemoryMap map, long sizeInBytes)
{
return map.CreateVariable<MockObject>(sizeInBytes, new MemoryMap.ReadFromDelegate<MockObject>(
(Stream stream, long position, ref MockObject value) =>
{
var payload = string.Empty;
var size = MemoryMapDelegates.ReadFromString(stream, position, ref payload);
value = new MockObject(payload);
return size;
}),
new MemoryMap.WriteToDelegate<MockObject>(
(Stream stream, long position, ref MockObject value) =>
{
var payload = value.Payload;
return MemoryMapDelegates.WriteToString(stream, position, ref payload);
}));
}
public void RemoveAddTest()
{
var add = new MockObject();
for (int i = 0; i < 10; i++)
{
_target.Add(add);
}
_target.Remove(3);
int expected = 3;
int actual = _target.Add(add);
Assert.AreEqual(expected, actual);
_target.Remove(0);
expected = 0;
actual = _target.Add(add);
Assert.AreEqual(expected, actual);
//make sure out of bounds doesn't throw
_target.Remove(int.MaxValue);
}
private void IsNotEqual_NullFirstParam_DoesNothing()
{
var objB = new MockObject();
Assert.IsNotEqual(null, objB);
}
private void IsEqual_NullFirstParam_ThrowsException()
{
var objB = new MockObject();
Assert.ThatThrowsException(() => { Assert.IsEqual(null, objB); },
typeof(Exception));
}
public void ValidateTest()
{
MockObject pv_objInstance = new MockObject();
PropertyInfo pv_objPropertyInfo = typeof(MockObject).GetProperty("MockProperty");
PaytonByrd_ProcessConfigurationTests.PaytonByrd_ProcessConfiguration_ProcessParameterAttributeAccessor.Validate(pv_objInstance, pv_objPropertyInfo);
}
private void IsEqual_NullSecondParam_ThrowsException()
{
var objA = new MockObject();
Assert.ThatThrowsException(() => { Assert.IsEqual(objA, null); },
typeof(Exception));
}
public void IntDictionaryComparisonTest()
{
const int TestSize = 10000000;
var intDic = new IntDictionary<MockObject>(32);
var dic = new Dictionary<int, MockObject>(32);
//jit shit.
var add = new MockObject();
add.Id = intDic.Add(add);
foreach (var kvp in intDic)
{
kvp.DoNothing();
}
intDic.Remove(add.Id);
add.Id = 0;
dic.Add(add.Id, add);
foreach (var kvp in dic)
{
kvp.Value.DoNothing();
}
dic.Remove(add.Id);
Stopwatch watch = new Stopwatch();
watch.Reset();
//the real tests
watch.Start();
for (int i = 0; i < TestSize; i++)
{
var foo = new MockObject();
foo.Id = intDic.Add(foo);
}
watch.Stop();
Debug.WriteLine("IntDic add: {0}", watch.Elapsed);
watch.Reset();
watch.Start();
for (int i = 0; i < TestSize; i++)
{
var foo = new MockObject();
foo.Id = i;
dic.Add(i, foo);
}
watch.Stop();
Debug.WriteLine("Dic add: {0}", watch.Elapsed);
watch.Reset();
watch.Start();
foreach (var kvp in intDic)
{
if (kvp != null)
kvp.DoNothing();
}
watch.Stop();
Debug.WriteLine("Intdic foreach: {0}", watch.Elapsed);
watch.Reset();
watch.Start();
foreach (var kvp in dic)
{
kvp.Value.DoNothing();
}
watch.Stop();
Debug.WriteLine("Dic foreach: {0}", watch.Elapsed);
watch.Reset();
watch.Start();
for (int i = 0; i < intDic.Capacity; i++)
{
MockObject value;
if (intDic.TryGetValue(i, out value))
value.DoNothing();
}
watch.Stop();
Debug.WriteLine("Intdic for: {0}", watch.Elapsed);
watch.Reset();
const int halfSize = TestSize / 2;
watch.Start();
for (int i = 0; i < halfSize; i++)
{
intDic.Remove(i);
}
watch.Stop();
Debug.WriteLine("Intdic remove: {0}", watch.Elapsed);
watch.Reset();
watch.Start();
for (int i = 0; i < halfSize; i++)
{
dic.Remove(i);
}
watch.Stop();
Debug.WriteLine("dic remove: {0}", watch.Elapsed);
watch.Reset();
watch.Start();
foreach (var kvp in intDic)
{
if (kvp != null)
kvp.DoNothing();
}
watch.Stop();
Debug.WriteLine("intdic foreach after remove: {0}", watch.Elapsed);
watch.Reset();
watch.Start();
foreach (var kvp in dic)
{
kvp.Value.DoNothing();
}
watch.Stop();
Debug.WriteLine("dic foreach after remove: {0}", watch.Elapsed);
watch.Reset();
}
public void SettingPolicyForMissingMethodDoesntThrow()
{
MethodExecutionStrategy strategy = new MethodExecutionStrategy();
MockBuilderContext ctx = new MockBuilderContext();
MockObject obj = new MockObject();
ctx.InnerChain.Add(strategy);
MethodPolicy policy = new MethodPolicy();
policy.Methods.Add("NonExistantMethod", new MethodCallInfo("NonExistantMethod"));
ctx.Policies.Set<IMethodPolicy>(policy, typeof (MockObject), null);
ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), obj, null);
}
public void StrategyCallsMultipleMethodsAndCallsThemInOrder()
{
MethodExecutionStrategy strategy = new MethodExecutionStrategy();
MockBuilderContext ctx = new MockBuilderContext();
MockObject obj = new MockObject();
ctx.InnerChain.Add(strategy);
MethodPolicy policy = new MethodPolicy();
policy.Methods.Add("ParameterlessMethod", new MethodCallInfo("ParameterlessMethod"));
policy.Methods.Add("IntMethod", new MethodCallInfo("IntMethod", new ValueParameter<int>(32)));
ctx.Policies.Set<IMethodPolicy>(policy, typeof (MockObject), null);
ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), obj, null);
Assert.AreEqual(1, obj.CallOrderParameterless);
Assert.AreEqual(2, obj.CallOrderInt);
}
public void StrategyDoesNothingWithNoPolicy()
{
MethodExecutionStrategy strategy = new MethodExecutionStrategy();
MockBuilderContext ctx = new MockBuilderContext();
MockObject obj = new MockObject();
ctx.InnerChain.Add(strategy);
ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), obj, null);
Assert.IsFalse(obj.ParameterlessWasCalled);
}
public void InferDBTableTest()
{
MockObject mo = new MockObject();
string expected = "MOCK_SIMPLE";
string actual = ReflectionUtils.InferDBTable(mo);
Assert.AreEqual(expected, actual);
Employee temp = new Employee();
expected = "EMPLOYEE";
actual = ReflectionUtils.InferDBTable(temp);
Assert.AreEqual(expected, actual);
}
private void IsNotEqual_NullSecondParam_DoesNothing()
{
var objA = new MockObject();
Assert.IsNotEqual(objA, null);
}
private void IsEqual_RefObjects_ThrowsException()
{
var objA = new MockObject();
var objB = new MockObject();
Assert.ThatThrowsException(() => { Assert.IsEqual(objA, objB); },
typeof(Exception));
}
public void SettingPolicyForWrongParameterCountDoesntThrow()
{
MethodExecutionStrategy strategy = new MethodExecutionStrategy();
MockBuilderContext ctx = new MockBuilderContext();
MockObject obj = new MockObject();
ctx.InnerChain.Add(strategy);
MethodPolicy policy = new MethodPolicy();
policy.Methods.Add("ParameterlessMethod", new MethodCallInfo("ParameterlessMethod", 123));
ctx.Policies.Set<IMethodPolicy>(policy, typeof (MockObject), null);
ctx.HeadOfChain.BuildUp(ctx, typeof (MockObject), obj, null);
}
public void InflationTest()
{
const int InflationTestSize = 300;
for (int i = 0; i < InflationTestSize; i++)
{
var add = new MockObject();
add.Id = _target.Add(add);
}
foreach (var add in _target)
{
_target.Remove(add.Id);
}
for (int i = 0; i < InflationTestSize; i++)
{
var add = new MockObject();
add.Id = _target.Add(add);
Assert.IsTrue(add.Id < InflationTestSize);
}
Assert.AreEqual(_target.Capacity, InflationTestSize);
}
