public void SectionStartMustBeGreaterThanZero()
{
Assert.Throws <ArgumentException>(() =>
{
ListBuilderExtensions.Section(listBuilderImpl, -1, 10);
});
}
public void TheNextAmountShouldBeGreaterThanOne()
{
using (mocks.Record())
listBuilderImpl.Expect(x => x.Capacity).Return(10);
ListBuilderExtensions.TheNext(listBuilderImpl, 0);
}
public void RandomAmountShouldBeLessThanListCapacity()
{
using (mocks.Record())
listBuilderImpl.Expect(x => x.Capacity).Return(10);
ListBuilderExtensions.Random(listBuilderImpl, 11);
}
public void IndexOfIndexMustBeZeroOrGreater()
{
Should.Throw <ArgumentOutOfRangeException>(() =>
{
ListBuilderExtensions.IndexOf(listBuilderImpl, -1);
});
}
public void SectionEndMustBeLessThanCapacity()
{
listBuilderImpl.Capacity.Returns(10);
Assert.Throws <ArgumentException>(
() => ListBuilderExtensions.Section(listBuilderImpl, 9, 10));
}
public void SectionStartCannotEqualEnd()
{
listBuilderImpl.Capacity.Returns(10);
Assert.Throws <ArgumentException>(
() => ListBuilderExtensions.Section(listBuilderImpl, 5, 5));
}
public void RandomAmountMustBeOneOrGreater()
{
Assert.Throws <ArgumentException>(() =>
{
ListBuilderExtensions.Random(listBuilderImpl, 0);
});
}
public void SectionCanCoverWholeList()
{
using (mocks.Record())
listBuilderImpl.Expect(x => x.Capacity).Return(10);
ListBuilderExtensions.Section(listBuilderImpl, 0, 9);
}
public void TheLastAmountMustBeOneOrGreater()
{
Should.Throw <ArgumentException>(() =>
{
ListBuilderExtensions.TheLast(listBuilderImpl, 0);
});
}
public void SectionEndMustBeLessThanCapacity()
{
using (mocks.Record())
listBuilderImpl.Expect(x => x.Capacity).Return(10);
Assert.Throws <ArgumentException>(
() => ListBuilderExtensions.Section(listBuilderImpl, 9, 10));
}
public void SectionStartMustBeLessThanEnd()
{
listBuilderImpl.Capacity.Returns(10);
// TODO FIX
Assert.Throws <ArgumentException>(
() => ListBuilderExtensions.Section(listBuilderImpl, 6, 5));
}
public void SectionEndMustBeGreaterThanOne()
{
listBuilderImpl.Capacity.Returns(10);
// TODO FIX
Assert.Throws <ArgumentException>(
() => ListBuilderExtensions.Section(listBuilderImpl, 0, 0));
}
public void IndexOfIndexShouldBeLessThanListCapacity()
{
listBuilderImpl.Capacity.Returns(10);
Should.Throw <ArgumentOutOfRangeException>(() =>
{
ListBuilderExtensions.IndexOf(listBuilderImpl, 11);
});
}
public void TheNextAmountShouldBeGreaterThanOne()
{
listBuilderImpl.Capacity.Returns(10);
Assert.Throws <ArgumentException>(() =>
{
ListBuilderExtensions.TheNext(listBuilderImpl, 0);
});
}
public void SectionStartMustBeLessThanCapacity()
{
listBuilderImpl.Capacity.Returns(10);
var ex = Assert.Throws <ArgumentException>(
() => ListBuilderExtensions.Section(listBuilderImpl, 10, 10));
Assert.That(ex.Message.Contains("start"));
}
public void RandomAmountShouldBeLessThanListCapacity()
{
listBuilderImpl.Capacity.Returns(10);
Assert.Throws <ArgumentException>(() =>
{
ListBuilderExtensions.Random(listBuilderImpl, 11);
});
}
public void SectionCanCoverWholeList()
{
listBuilderImpl.Capacity.Returns(10);
listBuilderImpl.BuilderSettings.Returns(new BuilderSettings());
listBuilderImpl.AddDeclaration(Arg.Any <IDeclaration <MyClass> >())
.Returns(new MyDeclaration <MyClass>());
ListBuilderExtensions.Section(listBuilderImpl, 0, 9);
}
public void TheLastAmountShouldBeLessThanListCapacity()
{
listBuilderImpl.Capacity.Returns(10);
Should.Throw <ArgumentException>(() =>
{
ListBuilderExtensions.TheLast(listBuilderImpl, 11);
});
}
public void RandomAmountShouldBeLessThanListCapacity()
{
using (mocks.Record())
listBuilderImpl.Expect(x => x.Capacity).Return(10);
Assert.Throws <ArgumentException>(() =>
{
ListBuilderExtensions.Random(listBuilderImpl, 11);
});
}
public void TheNextAmountShouldBeGreaterThanOne()
{
using (mocks.Record())
listBuilderImpl.Expect(x => x.Capacity).Return(10);
Assert.Throws <ArgumentException>(() =>
{
ListBuilderExtensions.TheNext(listBuilderImpl, 0);
});
}
public void SectionStartMustBeLessThanCapacity()
{
using (mocks.Record())
listBuilderImpl.Expect(x => x.Capacity).Return(10);
var ex = Assert.Throws <ArgumentException>(
() => ListBuilderExtensions.Section(listBuilderImpl, 10, 10));
Assert.That(ex.Message.Contains("start"));
}
public void SectionStartCannotEqualEnd()
{
using (mocks.Record())
listBuilderImpl.Expect(x => x.Capacity).Return(10);
// TODO FIX
#if !SILVERLIGHT
Assert.Throws <ArgumentException>(
() => ListBuilderExtensions.Section(listBuilderImpl, 5, 5));
#endif
}
public void SectionEndMustBeGreaterThanOne()
{
using (mocks.Record())
listBuilderImpl.Expect(x => x.Capacity).Return(10);
// TODO FIX
#if !SILVERLIGHT
Assert.Throws <ArgumentException>(
() => ListBuilderExtensions.Section(listBuilderImpl, 0, 0));
#endif
}
public void ShouldBeAbleToUseBuildHierarchy()
{
var hierarchySpec = Substitute.For <IHierarchySpec <MyClass> >();
listBuilderImpl.Build().Returns(new List <MyClass>());
var list = ListBuilderExtensions.BuildHierarchy(listBuilderImpl, hierarchySpec);
Assert.That(list, Is.TypeOf(typeof(List <MyClass>)));
}
public void ShouldBeAbleToUseBuildHierarchy()
{
var hierarchySpec = Substitute.For <IHierarchySpec <MyClass> >();
listBuilderImpl.Build().Returns(new List <MyClass>());
var list = ListBuilderExtensions.BuildHierarchy(listBuilderImpl, hierarchySpec);
list.ShouldBeOfType <List <MyClass> >();
}
public void TheFirstShouldReturnARangeDeclaration()
{
var rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 0, 0);
listBuilderImpl.Capacity.Returns(30);
listBuilderImpl.CreateObjectBuilder().Returns((IObjectBuilder <MyClass>)null);
listBuilderImpl.AddDeclaration(Arg.Is <RangeDeclaration <MyClass> >(y => y.Start == 0 && y.End == 9)).Returns(rangeDeclaration);
var declaration = ListBuilderExtensions.TheFirst(listBuilderImpl, 10);
Assert.That(declaration, Is.SameAs(rangeDeclaration));
}
public void ShouldBeAbleToUseSection()
{
var rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 10, 19);
listBuilderImpl.BuilderSettings.Returns(new BuilderSettings());
listBuilderImpl.Capacity.Returns(20);
listBuilderImpl.CreateObjectBuilder().Returns((IObjectBuilder <MyClass>)null);
listBuilderImpl.AddDeclaration(Arg.Is <RangeDeclaration <MyClass> >(y => y.Start == 10 && y.End == 19)).Returns(rangeDeclaration);
var whereSection = (RangeDeclaration <MyClass>)ListBuilderExtensions.Section(listBuilderImpl, 10, 19);
Assert.That(whereSection.Start, Is.EqualTo(10));
Assert.That(whereSection.End, Is.EqualTo(19));
}
public void ShouldOnlyAddTheDeclarationIfTheRangeIsValid()
{
IDeclarationQueue <MyClass> declarationQueue = Substitute.For <IDeclarationQueue <MyClass> >();
RangeDeclaration <MyClass> rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 0, 9);
listBuilderImpl.BuilderSettings.Returns(new BuilderSettings());
listBuilderImpl.CreateObjectBuilder().Returns((IObjectBuilder <MyClass>)null);
declarationQueue.GetLastItem().Returns(rangeDeclaration);
listBuilderImpl.Declarations.Returns(declarationQueue);
listBuilderImpl.AddDeclaration(Arg.Any <RangeDeclaration <MyClass> >()).Throws(new BuilderException(""));
Assert.Throws <BuilderException>(
() => ListBuilderExtensions.TheNext(listBuilderImpl, 30)
);
}
public void ShouldBeAbleToUsePersistHierarchy()
{
var buildersetup = new BuilderSettings();
var hierarchySpec = Substitute.For <IHierarchySpec <MyClass> >();
var persistenceService = Substitute.For <IPersistenceService>();
listBuilderImpl.BuilderSettings.Returns(buildersetup);
listBuilderImpl.Build().Returns(new List <MyClass>());
persistenceService.Create(Arg.Any <MyClass>());
persistenceService.Update(Arg.Any <IList <MyClass> >());
buildersetup.SetPersistenceService(persistenceService);
ListBuilderExtensions.PersistHierarchy(listBuilderImpl, hierarchySpec);
}
public void ShouldBeAbleToUseBuildHierarchy()
{
var hierarchySpec = mocks.Stub <IHierarchySpec <MyClass> >();
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.Build()).Return(new List <MyClass>()).Repeat.Any();
}
using (mocks.Playback())
{
var list = ListBuilderExtensions.BuildHierarchy(listBuilderImpl, hierarchySpec);
Assert.That(list, Is.TypeOf(typeof(List <MyClass>)));
}
}