public void ValueIsInitiallyCorrect()
{
var expectedValues = new[] { new object(), new object() };
var sut = new ValueCollectingVisitor(new object(), expectedValues);
Assert.Equal(expectedValues, sut.Value);
}
public void VisitAssemblyThrows()
{
var sut = new ValueCollectingVisitor(new object());
Assert.Throws <NotSupportedException>(
() => sut.Visit(this.GetType().Assembly.ToElement()));
}
public void DoesNotVisitElementsOtherThanPropertyAndField(
IReflectionElement element)
{
var sut = new ValueCollectingVisitor(new object());
var acceptResult = element.Accept(sut);
Assert.Equal(sut, acceptResult);
}
public void VisitNullPropertyElementThrows()
{
var sut = new ValueCollectingVisitor(new object());
var e = Assert.Throws <ArgumentNullException>(() =>
sut.Visit((PropertyInfoElement)null));
Assert.Equal("propertyInfoElement", e.ParamName);
}
public void VisitIncompatiblePropertyThrows()
{
var property = from p in new Properties <TypeWithProperties>()
select p.TheProperty;
var sut = new ValueCollectingVisitor(new Version());
Assert.Throws <ArgumentException>(
() => sut.Visit(property.ToElement()));
}
public void VisitIncompatibleFieldThrows()
{
var field = from f in new Fields <TypeWithFields>()
select f.TheField;
var sut = new ValueCollectingVisitor(new Version());
Assert.Throws <ArgumentException>(
() => sut.Visit(field.ToElement()));
}
public void ReadFromProperty()
{
PropertyInfo pi = from v in new Properties <Version>()
select v.Minor;
var version = new Version(2, 7);
var visitor = new ValueCollectingVisitor(version);
var actual = new PropertyInfoElement(pi).Accept(visitor);
Assert.Equal(version.Minor, actual.Value.OfType <int>().First());
}
public void ReadFromProperty()
{
PropertyInfo pi = from v in new Properties<Version>()
select v.Minor;
var version = new Version(2, 7);
var visitor = new ValueCollectingVisitor(version);
var actual = new PropertyInfoElement(pi).Accept(visitor);
Assert.Equal(version.Minor, actual.Value.OfType<int>().First());
}
public void VisitPropertyElementWithNoInitialValuesProducesTheCorrectValue()
{
// Arrange
var reflect = new Properties <TypeWithPublicIntValues>();
var target = new TypeWithPublicIntValues();
var expected = new object[] { target.Property2 };
var sut = new ValueCollectingVisitor(target);
var property = reflect.Select(x => x.Property2).ToElement();
// Act
var result = sut.Visit(property);
// Assert
Assert.Equal(expected, result.Value);
}
public void VisitFieldElementWithNoInitialValuesProducesTheCorrectValue()
{
// Arrange
var reflect = new Fields <TypeWithPublicIntValues>();
var target = new TypeWithPublicIntValues();
var expected = new object[] { target.Field2 };
var sut = new ValueCollectingVisitor(target);
var field = reflect.Select(x => x.Field2).ToElement();
// Act
var result = sut.Visit(field);
// Assert
Assert.Equal(expected, result.Value);
}
public void ReadFromSeveralPropertiesAndFields()
{
var ts = new TimeSpan(2, 4, 3, 8, 9);
var flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
var elements = ts.GetType()
.GetProperties(flags)
.Select(pi => new PropertyInfoElement(pi))
.Cast<IReflectionElement>()
.Concat(ts.GetType()
.GetFields(flags)
.Select(fi => new FieldInfoElement(fi))
.Cast<IReflectionElement>())
.ToArray();
var visitor = new ValueCollectingVisitor(ts);
var actual =
new CompositeReflectionElement(elements).Accept(visitor);
var actualValues = actual.Value.Cast<object>().ToArray();
Assert.Equal(elements.Length, actualValues.Length);
Assert.Equal(1, actualValues.Count(ts.Days.Equals));
Assert.Equal(1, actualValues.Count(ts.Hours.Equals));
Assert.Equal(1, actualValues.Count(ts.Milliseconds.Equals));
Assert.Equal(1, actualValues.Count(ts.Minutes.Equals));
Assert.Equal(1, actualValues.Count(ts.Seconds.Equals));
Assert.Equal(1, actualValues.Count(ts.Ticks.Equals));
Assert.Equal(1, actualValues.Count(ts.TotalDays.Equals));
Assert.Equal(1, actualValues.Count(ts.TotalHours.Equals));
Assert.Equal(1, actualValues.Count(ts.TotalMilliseconds.Equals));
Assert.Equal(1, actualValues.Count(ts.TotalMinutes.Equals));
Assert.Equal(1, actualValues.Count(ts.TotalSeconds.Equals));
Assert.Equal(1, actualValues.Count(TimeSpan.MaxValue.Equals));
Assert.Equal(1, actualValues.Count(TimeSpan.MinValue.Equals));
Assert.Equal(1, actualValues.Count(TimeSpan.TicksPerDay.Equals));
Assert.Equal(1, actualValues.Count(TimeSpan.TicksPerHour.Equals));
Assert.Equal(1, actualValues.Count(TimeSpan.TicksPerMillisecond.Equals));
Assert.Equal(1, actualValues.Count(TimeSpan.TicksPerMinute.Equals));
Assert.Equal(1, actualValues.Count(TimeSpan.TicksPerSecond.Equals));
Assert.Equal(1, actualValues.Count(TimeSpan.Zero.Equals));
}
public void AcceptPropertyElementsWithInitialValuesProducesTheCorrectValues()
{
// Arrange
var initialVisitorValues = new object[] { 9, 8, 7 };
var target = new TypeWithPublicIntValues();
var expected = initialVisitorValues
.Concat(new object[] { target.Property1, target.Property2, target.Property3 });
var reflect = new Properties <TypeWithPublicIntValues>();
var property1 = reflect.Select(x => x.Property1);
var property2 = reflect.Select(x => x.Property2);
var property3 = reflect.Select(x => x.Property3);
var propertyElements = new[] { property1, property2, property3 }
.Select(e => e.ToElement()).Cast <IReflectionElement>();
var sut = new ValueCollectingVisitor(target, initialVisitorValues);
// Act
var result = propertyElements.Accept(sut);
// Assert
Assert.Equal(expected, result.Value);
}
public void AcceptFieldElementsWithInitialValuesProducesTheCorrectValues()
{
// Arrange
var initialVisitorValues = new object[] { 9, 8, 7 };
var target = new TypeWithPublicIntValues();
var expected = initialVisitorValues
.Concat(new object[] { target.Field1, target.Field2, target.Field3 });
var reflect = new Fields <TypeWithPublicIntValues>();
var field1 = reflect.Select(x => x.Field1);
var field2 = reflect.Select(x => x.Field2);
var field3 = reflect.Select(x => x.Field3);
var fieldElements = new[] { field1, field2, field3 }
.Select(e => e.ToElement()).Cast <IReflectionElement>();
var sut = new ValueCollectingVisitor(target, initialVisitorValues);
// Act
var result = fieldElements.Accept(sut);
// Assert
Assert.Equal(expected, result.Value);
}
public void SutIsReflectionVisitor()
{
var sut = new ValueCollectingVisitor(new object());
Assert.IsAssignableFrom <ReflectionVisitor <IEnumerable <object> > >(sut);
}
