private MockActivator ActivatorFor(Task p)
{
MockActivator activator = new MockActivator();
((IActivatable)p).Bind(activator);
return(activator);
}
public void TestFieldSetterActivatesObject()
{
FieldSetterTestSubject obj = new FieldSetterTestSubject();
MockActivator a = ActivatorFor(obj);
Assert.AreEqual(0, a.ReadCount);
obj.intValue = 10;
int writeCount = 1;
Assert.AreEqual(writeCount++, a.WriteCount);
obj.refValue = null;
Assert.AreEqual(writeCount++, a.WriteCount);
obj.volatileByte = 3;
Assert.AreEqual(writeCount++, a.WriteCount);
Assert.AreEqual(0, a.ReadCount);
obj.valueType.intValue = 4;
Assert.AreEqual(1, a.ReadCount);
obj.valueType = new ValueTypeSubject(5);
Assert.AreEqual(writeCount++, a.WriteCount);
obj.intList = new List <int>(6);
Assert.AreEqual(writeCount++, a.WriteCount);
Assert.AreEqual(1, a.ReadCount);
}
public void _TestActivatableInheritedFromNonActivatableAccessingSuperField()
{
ActivatableInheritedFromNonActivatable subject = new ActivatableInheritedFromNonActivatable();
MockActivator a = ActivatorFor(subject);
Assert.IsTrue(subject.Equals(subject));
Assert.AreEqual(2, a.ReadCount);
}
public void _TestActivatableInheritedFromNonActivatableCallingSuper()
{
ActivatableInheritedFromNonActivatable subject = new ActivatableInheritedFromNonActivatable();
MockActivator a = ActivatorFor(subject);
subject.ToString();
Assert.AreEqual(1, a.ReadCount);
}
public void TestArbitraryArityGenericInstrumentation()
{
GenericContainerN <int, string, int> container = new GenericContainerN <int, string, int>();
MockActivator a = ActivatorFor(container);
Assert.AreEqual(0, container.Foo);
Assert.AreEqual(1, a.ReadCount);
}
public void TestCopyTo()
{
ArrayList4 <int> list = new ArrayList4 <int>();
MockActivator activator = MockActivator.ActivatorFor(list);
list.CopyTo(new int[1], 0);
Assert.AreEqual(1, activator.ReadCount());
}
public void TestVolatileAccess()
{
VolatileContainer container = new VolatileContainer();
MockActivator a = ActivatorFor(container);
Assert.AreEqual(0, container.Foo);
Assert.AreEqual(1, a.ReadCount);
}
public void TestGenericInstrumentation()
{
GenericContainer <int> container = new GenericContainer <int>();
MockActivator a = ActivatorFor(container);
Assert.AreEqual(0, container.Foo);
Assert.AreEqual(1, a.ReadCount);
}
public void TestGenericFieldOnGenericType()
{
GenericFieldOnGenericType <int> obj = new GenericFieldOnGenericType <int>();
MockActivator a = ActivatorFor(obj);
Assert.AreEqual(0, obj.Foo);
Assert.AreEqual(1, a.ReadCount);
}
public void TestGenericFieldContainer()
{
GenericFieldContainer container = new GenericFieldContainer();
MockActivator a = ActivatorFor(container);
Assert.IsNull(container.Foo);
Assert.AreEqual(1, a.ReadCount);
}
public void TestConstrainedGenericMethod()
{
Tagged obj = new Tagged("foo, bar");
MockActivator a = ActivatorFor(obj);
Assert.AreEqual("foo, bar", GenericMethods.ConstrainedMethod(obj));
Assert.AreEqual(1, a.ReadCount);
}
public void TestFieldByRef()
{
Project p1 = new Project("test");
MockActivator a1 = ActivatorFor(p1);
p1.UseByRef();
Assert.AreEqual(1, a1.ReadCount);
}
public void TestPropertyGetter()
{
Task p = new Task("test");
MockActivator activator = ActivatorFor(p);
Assert.AreEqual(0, activator.ReadCount);
Assert.AreEqual("test", p.Name);
Assert.AreEqual(1, activator.ReadCount);
}
public void TestGoto()
{
Activity activity = new Activity();
GotoSubject subject = new GotoSubject(activity);
MockActivator a = ActivatorFor(subject);
subject.Run(2);
ArrayAssert.AreEqual(new string[] { "before", "search", "search" }, activity.Checkpoints);
Assert.AreEqual(3, a.ReadCount);
}
public void TestSubjectHoldingArray()
{
SubjectHoldingArray subject = new SubjectHoldingArray();
MockActivator a = ActivatorFor(subject);
subject.Items = null;
Assert.AreEqual(1, a.WriteCount);
Assert.AreEqual(null, subject.Items);
Assert.AreEqual(1, a.ReadCount);
}
public void TestTryCatchWithoutException()
{
Activity activity = new Activity();
TryFinallySubject subject = new TryFinallySubject(activity);
MockActivator a = ActivatorFor(subject);
Assert.AreEqual("foo", subject.TryCatch("foo"));
ArrayAssert.AreEqual(new string[] { "BeforeTry", "Try", "Finally" }, activity.Checkpoints);
Assert.AreEqual(3, a.ReadCount);
}
public void TestGenericInherited()
{
GenericInherited obj = new GenericInherited();
MockActivator a = ActivatorFor(obj);
Assert.AreEqual(0, obj.Foo);
Assert.AreEqual(1, a.ReadCount);
Assert.AreEqual(0, obj.Bar);
Assert.AreEqual(2, a.ReadCount);
}
public void TestFieldAccessesInConstructors()
{
Item template = new Item();
MockActivator activator = ActivatorFor(template);
new Item(template);
Assert.AreEqual(2, activator.ReadCount);
Assert.AreEqual(0, activator.WriteCount);
}
public void TestTryCatchWithException()
{
Activity activity = new Activity();
TryFinallySubject subject = new TryFinallySubject(activity);
MockActivator a = ActivatorFor(subject);
Assert.IsInstanceOf(typeof(NullReferenceException), subject.TryCatch(null));
ArrayAssert.AreEqual(new string[] { "BeforeTry", "Catch", "Finally" }, activity.Checkpoints);
Assert.AreEqual(3, a.ReadCount);
}
public void TestFilteredOutClassesStillActivateForeignFields()
{
Assert.IsFalse(IsActivatable(typeof(FilteredOutByName)));
Task t = new Task("test");
MockActivator activator = ActivatorFor(t);
FilteredOutByName.CheckTask(t);
Assert.AreEqual(1, activator.ReadCount);
}
public void TestBindSameActivator()
{
Tagged obj = new Tagged("test");
MockActivator ma = ActivatorFor(obj);
IActivatable activatable = (IActivatable)obj;
activatable.Bind(ma);
string tags = obj.tags;
Assert.AreEqual(1, ma.ReadCount);
}
public void TestFilteredOutFieldAccess()
{
FilteredOut subject = new FilteredOut("test");
MockActivator activator = ActivatorFor(subject);
// TA instrumentation would normally
// instrument the field access on the
// next line EXCEPT that FilteredOut
// was filtered out
Assert.AreEqual("test", subject.foo);
Assert.AreEqual(0, activator.ReadCount);
}
public void TestForeignFieldAccess()
{
Project p1 = new Project("test");
Project p2 = new Project("test");
MockActivator a1 = ActivatorFor(p1);
MockActivator a2 = ActivatorFor(p2);
Assert.IsTrue(p1.Equals(p2));
Assert.AreEqual(1, a1.ReadCount);
Assert.AreEqual(1, a2.ReadCount);
}
public void TestForeignFieldAccess()
{
Task p1 = new Task("test");
Task p2 = new Task("test");
MockActivator a1 = ActivatorFor(p1);
MockActivator a2 = ActivatorFor(p2);
Assert.IsTrue(p1.Equals(p2));
Assert.AreEqual(1, a1.ReadCount, "a1");
Assert.AreEqual(1, a2.ReadCount, "a2");
}
public void TestBindDifferentActivator()
{
Tagged obj = new Tagged("test");
MockActivator ma = ActivatorFor(obj);
IActivatable activatable = (IActivatable)obj;
Assert.Expect(
typeof(InvalidOperationException),
delegate
{
activatable.Bind(ActivatorFor(obj));
});
}
public void TestIsTransient()
{
CustomActivatable ca = new CustomActivatable();
MockActivator ma = ActivatorFor(ca);
Assert.AreEqual(0, ma.ReadCount);
int n = ca._mustNotInstrumentMe;
Assert.AreEqual(0, ma.ReadCount);
n = ca._mustInstrumentAccess;
Assert.AreEqual(1, ma.ReadCount);
}
public void TestSwitch()
{
SwitchSubject subject = new SwitchSubject();
MockActivator a = ActivatorFor(subject);
subject.Update(1, "foo");
Assert.AreEqual(1, a.WriteCount);
Assert.AreEqual("foo", subject.Get(1));
Assert.AreEqual(1, a.ReadCount);
subject.Update(2, "bar");
Assert.AreEqual(2, a.WriteCount);
Assert.AreEqual("bar", subject.Get(2));
Assert.AreEqual(2, a.ReadCount);
}
private MockActivator ActivatorFor(object p)
{
return(MockActivator.ActivatorFor(p));
}
public void SetUp()
{
dict = CreateDictionary();
activator = MockActivator.ActivatorFor(dict);
}
