public void EqualsReturnsCorrectResultForFields()
{
// Fixture setup
var expected = true;
var comparerStubs = new[]
{
new DelegatingMemberComparer
{
OnIsSatisfiedByField = p => true,
OnEquals = (x, y) => false
},
new DelegatingMemberComparer
{
OnIsSatisfiedByField = p => true,
OnEquals = (x, y) => expected
},
new DelegatingMemberComparer
{
OnIsSatisfiedByField = p => true,
OnEquals = (x, y) => false
}
};
var sut = new SemanticComparer <FieldHolder <string> >(comparerStubs);
var value = new FieldHolder <string>();
var other = new FieldHolder <string>();
// Exercise system
var result = BothEquals(sut, value, other);
// Verify outcome
Assert.Equal(expected, result.All(b => b));
// Teardown
}
private void ProcessContent(int?oldSel)
{
StringBuilder sb = new StringBuilder();
int ind = 0;
mHolders = new List <FieldHolder>();
int partStart = 0;
int lfCount = 0;
foreach (Match m in mMatchCollection)
{
string part = mContents.Substring(partStart, m.Index - partStart);
sb.Append(part);
lfCount += part.Where(ch => ch == '\n').Count();
var fh = new FieldHolder(m, ind, lfCount);
ind++;
sb.Append(fh.Name);
partStart = m.Index + m.Length;
mHolders.Add(fh);
}
string theRest = string.Empty;
if (mHolders.Count != 0)
{
theRest = mContents.Substring(mHolders.Last().End);
}
else
{
theRest = mContents;
}
sb.Append(theRest);
mRichTextBox.Text = sb.ToString();
SelectField(oldSel);
}
public void ExecuteWillNotAssignFieldWhenContextReturnsOmitSpecimen()
{
// Arrange
var sut = new AutoPropertiesCommand <FieldHolder <object> >();
var specimen = new FieldHolder <object>();
var context = new DelegatingSpecimenContext
{
OnResolve = r => new OmitSpecimen()
};
// Act
sut.Execute((object)specimen, context);
// Assert
Assert.Null(specimen.Field);
}
public void ExecuteWillAssignCorrectFieldValue()
{
// Fixture setup
var expectedFieldValue = new object();
var container = new DelegatingSpecimenContext { OnResolve = r => expectedFieldValue };
var sut = new AutoPropertiesCommand<FieldHolder<object>>();
var specimen = new FieldHolder<object>();
// Exercise system
sut.Execute(specimen, container);
// Verify outcome
Assert.Equal(expectedFieldValue, specimen.Field);
// Teardown
}
public override void Parse(string[] args, ref int index)
{
if (FieldInfo.FieldType.Equals(typeof(Func <int, int, int>)))
{
string method = args[++index];
Func <int, int, int> computationLimitMethod;
if (method.Equals("?"))
{
computationLimitMethod = (computationLimit, clindex) =>
computationLimit == 1 ? 2 : computationLimit * computationLimit;
}
else if (method.Equals("inc"))
{
computationLimitMethod = (computationLimit, clindex) =>
computationLimit + ((int)FieldHolder.GetType( ).GetField("computationLimitIncrement").GetValue(FieldHolder));
}
else if (method.Equals("arr"))
{
int[] arr = new int[] { 4, 8, 16, 32, 64, 128, 256, 512, 10000 };
computationLimitMethod = (computationLimit, clindex) =>
arr[clindex];
}
else if (method.Equals("org-arr"))
{
//int[] arr = new int[] { 1, 5, 10, 20, 30, 40, 50, 100, 250, 500, 10000 };
int[] arr = new int[] { 1, 2, 3, 5, 7, 10, 15, 20, 25, 30, 35, 40, 45, 50, 100, 250, 500, 1000, 10000 };
computationLimitMethod = (computationLimit, clindex) =>
arr[clindex];
}
else if (method.StartsWith("exp-"))
{
double z = double.Parse(method.Substring(4));
computationLimitMethod = (computationLimit, clindex) =>
(int)Math.Pow(z, clindex);
}
else
{
throw new CommandLineException("Unknown Computation Limit Method");
}
FieldInfo.SetValue(FieldHolder, computationLimitMethod);
}
else
{
throw new CommandLineException("Invalid Field Type");
}
}
public void ExecuteWillNotAssignFieldWhenContextReturnsOmitSpecimen()
{
// Fixture setup
var sut = new AutoPropertiesCommand <FieldHolder <object> >();
var specimen = new FieldHolder <object>();
var context = new DelegatingSpecimenContext
{
OnResolve = r => new OmitSpecimen()
};
// Exercise system
sut.Execute(specimen, context);
// Verify outcome
Assert.Null(specimen.Field);
// Teardown
}
public void ComparingStringFieldHolderSemanticallyToRealStringFieldHolderWillIndicateEquality()
{
// Fixture setup
string anonymousText = "Anonymous text";
FieldHolder <string> likenObject = new FieldHolder <string>();
likenObject.Field = anonymousText;
FieldHolder <string> comparee = new FieldHolder <string>();
comparee.Field = anonymousText;
// The rest of the test
SemanticComparerTest.CompareSemantically(likenObject, comparee, true);
}
public void ExecuteWillAssignCorrectFieldValue()
{
// Arrange
var expectedFieldValue = new object();
var container = new DelegatingSpecimenContext {
OnResolve = r => expectedFieldValue
};
var sut = new AutoPropertiesCommand <FieldHolder <object> >();
var specimen = new FieldHolder <object>();
// Act
sut.Execute((object)specimen, container);
// Assert
Assert.Equal(expectedFieldValue, specimen.Field);
}
public void ExecuteDoesNotAssignFieldWhenSpecificationIsNotSatisfied()
{
// Arrange
var spec = new DelegatingRequestSpecification {
OnIsSatisfiedBy = r => false
};
var sut = new AutoPropertiesCommand <FieldHolder <object> >(spec);
var specimen = new FieldHolder <object>();
var container = new DelegatingSpecimenContext {
OnResolve = r => new object()
};
// Act
sut.Execute((object)specimen, container);
// Assert
Assert.Null(specimen.Field);
}
public void ComparingStringFieldHoldersWithDifferentValuesWillIndicateDifference()
{
// Fixture setup
string anonymousText1 = "Anonymous text";
string anonymousText2 = "Some other text";
FieldHolder <string> likenObject = new FieldHolder <string>();
likenObject.Field = anonymousText1;
FieldHolder <string> comparee = new FieldHolder <string>();
comparee.Field = anonymousText2;
// The rest of the test
SemanticComparerTest.CompareSemantically(likenObject, comparee, false);
}
public void ExecuteWillQuerySpecificationWithCorrectFieldInfo()
{
// Arrange
var expectedFieldInfo = typeof(FieldHolder <string>).GetField("Field");
var verified = false;
var specMock = new DelegatingRequestSpecification {
OnIsSatisfiedBy = r => verified = expectedFieldInfo.Equals(r)
};
var sut = new AutoPropertiesCommand <FieldHolder <string> >(specMock);
// Act
var specimen = new FieldHolder <string>();
var dummyContainer = new DelegatingSpecimenContext();
sut.Execute((object)specimen, dummyContainer);
// Assert
Assert.True(verified, "Mock verified");
}
public void CompareAnonymousTypeSemanticallyToStringFieldHolderWillIndicateEqualityWhenValuesAreEqual()
{
// Fixture setup
string anonymousText = "Anonymous text";
var likenObject = new
{
Field = anonymousText
};
FieldHolder <string> comparee = new FieldHolder <string>();
comparee.Field = anonymousText;
// The rest of the test
SemanticComparerTest.CompareSemantically(likenObject, comparee, true);
}
public void ExecuteWillAssignCorrectFieldValue()
{
// Fixture setup
var expectedFieldValue = new object();
var container = new DelegatingSpecimenContext {
OnResolve = r => expectedFieldValue
};
var sut = new AutoPropertiesCommand <FieldHolder <object> >();
var specimen = new FieldHolder <object>();
// Exercise system
sut.Execute(specimen, container);
// Verify outcome
Assert.Equal(expectedFieldValue, specimen.Field);
// Teardown
}
public void ExecuteWillQuerySpecificationWithCorrectFieldInfo()
{
// Fixture setup
var expectedFieldInfo = typeof(FieldHolder <string>).GetField("Field");
var verified = false;
var specMock = new DelegatingRequestSpecification {
OnIsSatisfiedBy = r => verified = expectedFieldInfo.Equals(r)
};
var sut = new AutoPropertiesCommand <FieldHolder <string> >(specMock);
// Exercise system
var specimen = new FieldHolder <string>();
var dummyContainer = new DelegatingSpecimenContext();
sut.Execute(specimen, dummyContainer);
// Verify outcome
Assert.True(verified, "Mock verified");
// Teardown
}
public void ExecuteDoesNotAssignFieldWhenSpecificationIsNotSatisfied()
{
// Fixture setup
var spec = new DelegatingRequestSpecification {
OnIsSatisfiedBy = r => false
};
var sut = new AutoPropertiesCommand <FieldHolder <object> >(spec);
var specimen = new FieldHolder <object>();
var container = new DelegatingSpecimenContext {
OnResolve = r => new object()
};
// Exercise system
sut.Execute(specimen, container);
// Verify outcome
Assert.Null(specimen.Field);
// Teardown
}
public void CompareAnonymousTypeSemanticallyToStringPropertyHolderWillIndicateDifferenceWhenValuesAreDifferent()
{
// Fixture setup
string anonymousText1 = "Anonymous text";
string anonymousText2 = "Some other text";
var likenObject = new
{
Field = anonymousText1
};
FieldHolder <string> comparee = new FieldHolder <string>();
comparee.Field = anonymousText2;
// The rest of the test
SemanticComparerTest.CompareSemantically(likenObject, comparee, false);
}
public void ExecuteSetsCorrectFieldOnSpecimenWhenAnonymousValueIsImplied()
{
// Arrange
var expectedValue = new object();
var expectedRequest = typeof(FieldHolder <object>).GetField("Field");
var context = new DelegatingSpecimenContext
{
OnResolve = r => expectedRequest.Equals(r) ? expectedValue : new NoSpecimen()
};
var sut = new BindingCommand <FieldHolder <object>, object>(ph => ph.Field);
var specimen = new FieldHolder <object>();
// Act
sut.Execute((object)specimen, context);
// Assert
Assert.Equal(expectedValue, specimen.Field);
}
public void ExecuteWillSetCorrectFieldOnSpecimenWhenAnonymousValueIsImplied()
{
// Fixture setup
var expectedValue = new object();
var expectedRequest = typeof(FieldHolder <object>).GetField("Field");
var container = new DelegatingSpecimenContext {
OnResolve = r => expectedRequest.Equals(r) ? expectedValue : new NoSpecimen()
};
var sut = new BindingCommand <FieldHolder <object>, object>(ph => ph.Field);
var specimen = new FieldHolder <object>();
// Exercise system
sut.Execute(specimen, container);
// Verify outcome
Assert.Equal(expectedValue, specimen.Field);
// Teardown
}
public void ExecuteWillSetCorrectFieldOnSpecimenWhenAnonymousValueIsImplied()
{
// Arrange
var expectedValue = new object();
var expectedRequest = typeof(FieldHolder <object>).GetField("Field");
var container = new DelegatingSpecimenContext {
OnResolve = r => expectedRequest.Equals(r) ? expectedValue : new NoSpecimen()
};
var sut = new BindingCommand <FieldHolder <object>, object>(ph => ph.Field);
var specimen = new FieldHolder <object>();
// Act
#pragma warning disable 618
sut.Execute(specimen, container);
#pragma warning restore 618
// Assert
Assert.Equal(expectedValue, specimen.Field);
}
public void FreezeFirstParameterByFieldWithDifferentNameShouldNotAssignSameInstanceToSecondParameter(
[Frozen(Matching.FieldName)]string p1,
FieldHolder<object> p2)
{
Assert.NotEqual(p1, p2.Field);
}
public void FreezeFirstParameterByFieldWithSameNameShouldAssignSameInstanceToSecondParameter(
[Frozen(Matching.FieldName)]string field,
FieldHolder<object> p2)
{
Assert.Equal(field, p2.Field);
}
public void FreezeFirstParameterByMemberWithDifferentNameShouldNotAssignSameInstanceToFieldOfSameType(
[Frozen(Matching.MemberName)] string p1,
FieldHolder <string> p2)
{
Assert.NotEqual(p1, p2.Field);
}
public void FreezeFirstParameterByMemberWithSameNameShouldAssignSameInstanceToMatchingField(
[Frozen(Matching.MemberName)] string field,
FieldHolder <object> p2)
{
Assert.Equal(field, p2.Field);
}
public void FreezeFirstParameterByFieldWithDifferentNameShouldNotAssignSameInstanceToSecondParameter(
[Frozen(Matching.FieldName)] string p1,
FieldHolder <object> p2)
{
Assert.NotEqual(p1, p2.Field);
}
public void FreezeFirstParameterByFieldWithSameNameShouldAssignSameInstanceToSecondParameter(
[Frozen(Matching.FieldName)] string field,
FieldHolder <object> p2)
{
Assert.Equal(field, p2.Field);
}
public void ExecuteWillQuerySpecificationWithCorrectFieldInfo()
{
// Fixture setup
var expectedFieldInfo = typeof(FieldHolder<string>).GetField("Field");
var verified = false;
var specMock = new DelegatingRequestSpecification { OnIsSatisfiedBy = r => verified = expectedFieldInfo.Equals(r) };
var sut = new AutoPropertiesCommand<FieldHolder<string>>(specMock);
// Exercise system
var specimen = new FieldHolder<string>();
var dummyContainer = new DelegatingSpecimenContext();
sut.Execute(specimen, dummyContainer);
// Verify outcome
Assert.True(verified, "Mock verified");
// Teardown
}
public void FreezeFirstParameterByMemberWithSameNameShouldAssignSameInstanceToMatchingField(
[Frozen(Matching.MemberName)]string field,
FieldHolder<object> p2)
{
Assert.Equal(field, p2.Field);
}
public void ExecuteDoesNotAssignFieldWhenSpecificationIsNotSatisfied()
{
// Fixture setup
var spec = new DelegatingRequestSpecification { OnIsSatisfiedBy = r => false };
var sut = new AutoPropertiesCommand<FieldHolder<object>>(spec);
var specimen = new FieldHolder<object>();
var container = new DelegatingSpecimenContext { OnResolve = r => new object() };
// Exercise system
sut.Execute(specimen, container);
// Verify outcome
Assert.Null(specimen.Field);
// Teardown
}
public void ExecuteSetsCorrectFieldOnSpecimenWhenAnonymousValueIsImplied()
{
// Fixture setup
var expectedValue = new object();
var expectedRequest = typeof(FieldHolder<object>).GetField("Field");
var context = new DelegatingSpecimenContext
{
OnResolve = r => expectedRequest.Equals(r) ? expectedValue : new NoSpecimen()
};
var sut = new BindingCommand<FieldHolder<object>, object>(ph => ph.Field);
var specimen = new FieldHolder<object>();
// Exercise system
sut.Execute((object)specimen, context);
// Verify outcome
Assert.Equal(expectedValue, specimen.Field);
// Teardown
}
public void FreezeFirstParameterByMemberWithDifferentNameShouldNotAssignSameInstanceToFieldOfSameType(
[Frozen(Matching.MemberName)]string p1,
FieldHolder<string> p2)
{
Assert.NotEqual(p1, p2.Field);
}
public void ExecuteWillNotAssignFieldWhenContextReturnsOmitSpecimen()
{
// Fixture setup
var sut = new AutoPropertiesCommand<FieldHolder<object>>();
var specimen = new FieldHolder<object>();
var context = new DelegatingSpecimenContext
{
OnResolve = r => new OmitSpecimen()
};
// Exercise system
sut.Execute(specimen, context);
// Verify outcome
Assert.Null(specimen.Field);
// Teardown
}
