Esempio n. 1
0
        /// <summary>
        /// Returns the entries that meet the include delegates criteria,
        /// with the number of entries limited by <see paramref="maxResults" />.
        /// </summary>
        /// <param name="include">The delegate indicating which items to include.</param>
        public EntryCollection GetEntries(Predicate <Entry> include, int maxResults)
        {
            lock (entriesLock)
            {
                Predicate <Entry> filter = null;

                if (System.Threading.Thread.CurrentPrincipal != null)
                {
                    if (!System.Threading.Thread.CurrentPrincipal.IsInRole("admin"))
                    {
                        filter += EntryCollectionFilter.DefaultFilters.IsPublic();
                    }
                }
                else
                {
                    filter += EntryCollectionFilter.DefaultFilters.IsPublic();
                }

                if (include != null)
                {
                    filter += include;
                }

                return(EntryCollectionFilter.FindAll(Entries, filter, maxResults));
            }
        }
        public void EntryCollections_FilterAndMaxResults_OnlyReturnsOneEntry()
        {
            var entry1 = CreateEntry("public 2007.1", true, new DateTime(2007, 2, 2));
            var entry2 = CreateEntry("public 2006.1", true, new DateTime(2006, 2, 2));
            var entry3 = CreateEntry("not public 2006.1", false, new DateTime(2006, 2, 2));
            var entry4 = CreateEntry("public 2007.2", true, new DateTime(2007, 2, 2));
            var entry5 = CreateEntry("public 2006.2", true, new DateTime(2006, 2, 2));
            var entry6 = CreateEntry("not public 2006.2", false, new DateTime(2006, 2, 2));

            var collection = new EntryCollection(new Entry[] { entry1, entry2, entry3, entry4, entry5, entry6 });

            Predicate <Entry> filter = null;

            Predicate <Entry> isPublic = delegate(Entry e)
            {
                return(e.IsPublic);
            };

            filter += isPublic;

            Predicate <Entry> is2006Published = delegate(Entry e)
            {
                return(e.CreatedLocalTime.Year == 2006);
            };

            filter += is2006Published;

            // 2 items match the criteria (2,5), we only want 1 returned
            var filtered = EntryCollectionFilter.FindAll(collection, filter, 1);

            Assert.Single(filtered);
        }
        public void EntryCollections_FilteringPublicEntries_CountsShouldDifferAfterFiltering()
        {
            var entry1 = CreateEntry("public 2007", true, new DateTime(2007, 2, 2));
            var entry2 = CreateEntry("public 2006", true, new DateTime(2006, 2, 2));
            var entry3 = CreateEntry("not public 2006", false, new DateTime(2006, 2, 2));

            var collection = new EntryCollection(new Entry[] { entry1, entry2, entry3 });

            Predicate <Entry> filter = null;

            Predicate <Entry> isPublic = delegate(Entry e)
            {
                return(e.IsPublic);
            };

            filter += isPublic;

            Predicate <Entry> is2006Published = delegate(Entry e)
            {
                return(e.CreatedLocalTime.Year == 2006);
            };

            filter += is2006Published;

            var classic = EntryCollectionFilter.FindAll(collection, filter);
            var generic = collection.FindAll(filter);

            Assert.NotEqual(classic.Count, generic.Count);
        }
        public void FilterTest()
        {
            Entry entry1 = CreateEntry("public 2007", true, new DateTime(2007, 2, 2));
            Entry entry2 = CreateEntry("public 2006", true, new DateTime(2006, 2, 2));
            Entry entry3 = CreateEntry("not public 2006", false, new DateTime(2006, 2, 2));

            EntryCollection collection = new EntryCollection(new Entry[] { entry1, entry2, entry3 });

            Predicate <Entry> filter = null;

            Predicate <Entry> isPublic = delegate(Entry e)
            {
                return(e.IsPublic);
            };

            filter += isPublic;

            Predicate <Entry> is2006Published = delegate(Entry e)
            {
                return(e.CreatedLocalTime.Year == 2006);
            };

            filter += is2006Published;

            EntryCollection classic = EntryCollectionFilter.FindAll(collection, filter);
            List <Entry>    generic = collection.FindAll(filter);

            Assert.AreNotEqual(classic.Count, generic.Count, "Number of items doesn't match.");
        }
        public void EntryCollections_NoFilterMaxResults_OnlyReturnsFourEntries()
        {
            var entry1 = CreateEntry("public 2007.1", true, new DateTime(2007, 2, 2));
            var entry2 = CreateEntry("public 2006.1", true, new DateTime(2006, 2, 2));
            var entry3 = CreateEntry("not public 2006.1", false, new DateTime(2006, 2, 2));
            var entry4 = CreateEntry("public 2007.2", true, new DateTime(2007, 2, 2));
            var entry5 = CreateEntry("public 2006.2", true, new DateTime(2006, 2, 2));
            var entry6 = CreateEntry("not public 2006.2", false, new DateTime(2006, 2, 2));

            var collection = new EntryCollection(new Entry[] { entry1, entry2, entry3, entry4, entry5, entry6 });

            // no predicate so all results should be returend but we only want 4
            var maxResults = EntryCollectionFilter.FindAll(collection, null, 4);

            Assert.Equal(4, maxResults.Count);
        }
        public void MaxResultsTest()
        {
            Entry entry1 = CreateEntry("public 2007.1", true, new DateTime(2007, 2, 2));
            Entry entry2 = CreateEntry("public 2006.1", true, new DateTime(2006, 2, 2));
            Entry entry3 = CreateEntry("not public 2006.1", false, new DateTime(2006, 2, 2));
            Entry entry4 = CreateEntry("public 2007.2", true, new DateTime(2007, 2, 2));
            Entry entry5 = CreateEntry("public 2006.2", true, new DateTime(2006, 2, 2));
            Entry entry6 = CreateEntry("not public 2006.2", false, new DateTime(2006, 2, 2));

            EntryCollection collection = new EntryCollection(new Entry[] { entry1, entry2, entry3, entry4, entry5, entry6 });

            Predicate <Entry> filter = null;

            Predicate <Entry> isPublic = delegate(Entry e)
            {
                return(e.IsPublic);
            };

            filter += isPublic;

            Predicate <Entry> is2006Published = delegate(Entry e)
            {
                return(e.CreatedLocalTime.Year == 2006);
            };

            filter += is2006Published;

            // 2 items match the criteria (2,5), we only want 1 returned
            EntryCollection filtered = EntryCollectionFilter.FindAll(collection, filter, 1);

            Assert.AreEqual(1, filtered.Count, "Number of results doesn't match.");

            // no predicate so all results should be returend but we only want 4
            EntryCollection maxResults = EntryCollectionFilter.FindAll(collection, null, 4);

            Assert.AreEqual(4, maxResults.Count, "Number of results doesn't match.");
        }