// ReSharper disable PossibleMultipleEnumeration
private void Init(ICollectionFacet collectionFacet, INakedObjectAdapter collection, IEnumerable <object> data1, IEnumerable <object> data2)
{
collectionFacet.Init(collection, data1.Select(AdapterFor).ToArray());
ValidateCollection(collectionFacet, collection, data1);
collectionFacet.Init(collection, data2.Select(AdapterFor).ToArray());
ValidateCollection(collectionFacet, collection, data2);
}
private void Page(ICollectionFacet testArrayFacet, INakedObject collection, object first) {
INakedObject pagedCollection = testArrayFacet.Page(1, 1, collection, false);
var pagedCollectionFacet = new DotNetGenericIEnumerableFacet<object>(facetHolder, typeof (object), false);
Assert.IsTrue(pagedCollectionFacet.AsEnumerable(pagedCollection).Count() == 1);
Assert.AreSame(pagedCollectionFacet.AsEnumerable(pagedCollection).First().Object, first);
}
private string CollectionTitleString(ICollectionFacet facet)
{
var size = CanCount() ? facet.AsEnumerable(this, nakedObjectManager).Count() : CollectionUtils.IncompleteCollection;
var elementSpecification = TypeOfFacet == null ? null : metamodel.GetSpecification(TypeOfFacet.GetValueSpec(this, metamodel.Metamodel));
return(CollectionUtils.CollectionTitleString(elementSpecification, size));
}
// ReSharper restore PossibleMultipleEnumeration
private void Page(ICollectionFacet testArrayFacet, INakedObjectAdapter collection, object first)
{
var pagedCollection = testArrayFacet.Page(1, 1, collection, manager, false);
Assert.IsTrue(((IEnumerable)pagedCollection.Object).Cast <string>().Count() == 1);
Assert.AreSame(((IEnumerable)pagedCollection.Object).Cast <string>().First(), first);
}
// ReSharper disable PossibleMultipleEnumeration
private void ValidateCollection(ICollectionFacet collectionFacet, INakedObjectAdapter collection, IEnumerable <object> objects)
{
INakedObjectAdapter[] collectionAsEnumerable = collectionFacet.AsEnumerable(collection, manager).ToArray();
Assert.AreEqual(collectionAsEnumerable.Count(), objects.Count());
IEnumerable <Tuple <object, object> > zippedCollections = collectionAsEnumerable.Zip(objects, (no, o1) => new Tuple <object, object>(no.Object, o1));
zippedCollections.ForEach(t => Assert.AreSame(t.Item1, t.Item2));
}
// ReSharper disable PossibleMultipleEnumeration
private void ValidateCollection(ICollectionFacet collectionFacet, INakedObjectAdapter collection, IEnumerable <object> objects)
{
var collectionAsEnumerable = collectionFacet.AsEnumerable(collection, manager).ToArray();
Assert.AreEqual(collectionAsEnumerable.Length, objects.Count());
IEnumerable <(object adaptedObject, object obj)> zippedCollections = collectionAsEnumerable.Zip(objects, (no, o1) => (no.Object, o1));
zippedCollections.ForEach(t => Assert.AreSame(t.adaptedObject, t.obj));
}
private void InitObjectSetupCollection(INakedObject nakedObject, ObjectData data, INakedObjectAssociation field)
{
/*
* The internal collection is already a part of the object, and therefore cannot be recreated, but its
* oid must be set
*/
IList <IOid> refs = (IList <IOid>)data.GetField(field.Id) ?? new List <IOid>();
INakedObject collection = field.GetNakedObject(nakedObject);
collection.ResolveState.Handle(Events.StartResolvingEvent);
var elements = new List <INakedObject>();
foreach (IOid elementOid in refs)
{
INakedObject adapter = Persistor.GetAdapterFor(elementOid) ?? GetObject(elementOid, null);
elements.Add(adapter);
}
ICollectionFacet facet = collection.GetCollectionFacetFromSpec();
facet.Init(collection, elements.ToArray());
collection.ResolveState.Handle(Events.EndResolvingEvent);
}
private static void ValidateCollection(ICollectionFacet collectionFacet, INakedObject collection, IEnumerable<object> objects) {
IEnumerable<INakedObject> collectionAsEnumerable = collectionFacet.AsEnumerable(collection);
Assert.AreEqual(collectionAsEnumerable.Count(), objects.Count());
IEnumerable<Tuple<object, object>> zippedCollections = collectionAsEnumerable.Zip(objects, (no, o1) => new Tuple<object, object>(no.Object, o1));
zippedCollections.ForEach(t => Assert.AreSame(t.Item1, t.Item2));
}
private void Size(ICollectionFacet collectionFacet, INakedObjectAdapter collection)
{
Assert.AreEqual(2, collectionFacet.AsEnumerable(collection, manager).Count());
}
// ReSharper restore PossibleMultipleEnumeration
private void FirstElement(ICollectionFacet collectionFacet, INakedObjectAdapter collection, object first) {
Assert.AreSame(first, collectionFacet.AsEnumerable(collection, manager).First().Object);
}
// ReSharper disable PossibleMultipleEnumeration
private void Init(ICollectionFacet collectionFacet, INakedObjectAdapter collection, IEnumerable<object> data1, IEnumerable<object> data2) {
collectionFacet.Init(collection, data1.Select(AdapterFor).ToArray());
ValidateCollection(collectionFacet, collection, data1);
collectionFacet.Init(collection, data2.Select(AdapterFor).ToArray());
ValidateCollection(collectionFacet, collection, data2);
}
// ReSharper disable PossibleMultipleEnumeration
private void ValidateCollection(ICollectionFacet collectionFacet, INakedObjectAdapter collection, IEnumerable<object> objects) {
INakedObjectAdapter[] collectionAsEnumerable = collectionFacet.AsEnumerable(collection, manager).ToArray();
Assert.AreEqual(collectionAsEnumerable.Count(), objects.Count());
IEnumerable<Tuple<object, object>> zippedCollections = collectionAsEnumerable.Zip(objects, (no, o1) => new Tuple<object, object>(no.Object, o1));
zippedCollections.ForEach(t => Assert.AreSame(t.Item1, t.Item2));
}
private void Init(ICollectionFacet collectionFacet, INakedObject collection, IEnumerable<object> data1, IEnumerable<object> data2) {
collectionFacet.Init(collection, data1.Cast<object>().Select(x => testSystem.AdapterFor(x)).ToArray());
ValidateCollection(collectionFacet, collection, data1);
collectionFacet.Init(collection, data2.Cast<object>().Select(x => testSystem.AdapterFor(x)).ToArray());
ValidateCollection(collectionFacet, collection, data2);
}
// ReSharper restore PossibleMultipleEnumeration
private void Page(ICollectionFacet testArrayFacet, INakedObjectAdapter collection, object first) {
INakedObjectAdapter pagedCollection = testArrayFacet.Page(1, 1, collection, manager, false);
Assert.IsTrue(((IEnumerable) pagedCollection.Object).Cast<string>().Count() == 1);
Assert.AreSame(((IEnumerable) pagedCollection.Object).Cast<string>().First(), first);
}
// ReSharper restore PossibleMultipleEnumeration
private void FirstElement(ICollectionFacet collectionFacet, INakedObjectAdapter collection, object first)
{
Assert.AreSame(first, collectionFacet.AsEnumerable(collection, manager).First().Object);
}
private static void Size(ICollectionFacet collectionFacet, INakedObject collection) {
Assert.AreEqual(2, collectionFacet.AsEnumerable(collection).Count());
}
private string CollectionTitleString(ICollectionFacet facet) {
int size = ElementsLoaded() ? facet.AsEnumerable(this).Count() : CollectionUtils.IncompleteCollection;
INakedObjectSpecification elementSpecification = TypeOfFacet == null ? null : TypeOfFacet.ValueSpec;
return CollectionUtils.CollectionTitleString(elementSpecification, size);
}
private static INakedObject DoPaging(INakedObject nakedObject, ICollectionFacet collectionfacet, int page, int pageSize, bool forceEnumerable) {
INakedObject newNakedObject = collectionfacet.Page(page, pageSize, nakedObject, forceEnumerable);
object[] objects = newNakedObject.GetAsEnumerable().Select(no => no.Object).ToArray();
newNakedObject.SetATransientOid(new CollectionMemento(nakedObject.Oid as CollectionMemento, objects) {IsPaged = true});
return newNakedObject;
}
private void Contains(ICollectionFacet collectionFacet, INakedObjectAdapter collection, object first, object second)
{
Assert.IsTrue(collectionFacet.Contains(collection, AdapterFor(first)));
Assert.IsFalse(collectionFacet.Contains(collection, AdapterFor(second)));
}
private static void FirstElement(ICollectionFacet collectionFacet, INakedObject collection, object first) {
Assert.AreSame(first, collectionFacet.AsEnumerable(collection).First().Object);
}
private void Contains(ICollectionFacet collectionFacet, INakedObject collection, object first, object second) {
Assert.IsTrue(collectionFacet.Contains(collection, testSystem.AdapterFor(first)));
Assert.IsFalse(collectionFacet.Contains(collection, testSystem.AdapterFor(second)));
}
private void Size(ICollectionFacet collectionFacet, INakedObjectAdapter collection) {
Assert.AreEqual(2, collectionFacet.AsEnumerable(collection, manager).Count());
}
