public void IncludeIfEventLevelGreaterThanOrEqualToLevelFilter(SystemEventLevel level)
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { LevelFilter = SystemEventLevel.Warning };
            dynamicFilter.Update();

            Assert.False(dynamicFilter.Exclude(new SystemEvent { Level = level }));
        }
        public void ReturnTrueIfSystemEventProperty()
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter);

            foreach (var property in typeof(SystemEvent).GetProperties())
                Assert.True(dynamicFilter.HasProperty(property.Name));
        }
        public void DoNotIncludeCompositeFilterTypes(Object type)
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter);
            var friendlyNames = dynamicFilter.GetSupportedFilterNames((Type)type);

            Assert.Equal(0, friendlyNames.Intersect(CompositeFilterNames).Count());
        }
        public void IncludeIfPositiveFilterDefinition()
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { TextFilters = new[] { FilterDefinition.ForPositiveExpression("Source", "Equal To", "Some Value") } };
            dynamicFilter.Update();

            Assert.False(dynamicFilter.Exclude(new SystemEvent { Source = "Some Value" }));
        }
        public void ExcludeIfNegativeFilterDefinition()
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { TextFilters = new[] { FilterDefinition.ForNegativeExpression("Message", "Equal To", "Some Value") } };
            dynamicFilter.Update();

            Assert.True(dynamicFilter.Exclude(new SystemEvent { Message = "Some Value" }));
        }
        public void IncludeIfEventProcessIdEqualToAnyProcessFilter(Int32 processId)
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { ProcessFilters = new[] { 2, 4, 8, 16 } };
            dynamicFilter.Update();

            Assert.False(dynamicFilter.Exclude(new SystemEvent { ProcessId = processId }));
        }
        public void ExcludeIfEventLevelLessThanLevelFilter(SystemEventLevel level)
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { LevelFilter = SystemEventLevel.Warning };
            dynamicFilter.Update();

            Assert.True(dynamicFilter.Exclude(new SystemEvent { Level = level }));
        }
        public void IncludeIfEventProcessNameEqualToAnyApplicationFilter(String processName)
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { ApplicationFilters = new[] { "Abc", "Xyz", "123" } };
            dynamicFilter.Update();

            Assert.False(dynamicFilter.Exclude(new SystemEvent { ProcessName = processName }));
        }
        public void ApplicationNameFilterIsCaseSensitive(String processName)
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { ApplicationFilters = new[] { "Abc" } };
            dynamicFilter.Update();

            Assert.True(dynamicFilter.Exclude(new SystemEvent { ProcessName = processName }));
        }
        public void FiltersDefinitionsBySourceProperty()
        {
            var textFilters = new[] { FilterDefinition.ForPositiveExpression("Source", "Equal To", "Some Value"), FilterDefinition.ForPositiveExpression("Message", "Equal To", "Another Value") };
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { TextFilters = textFilters };
            dynamicFilter.Update();

            Assert.False(dynamicFilter.Exclude(new SystemEvent { Source = "Some Value", Message = "Another Value" }));
        }
        public FilterByLevel(DynamicFilterExpression dynamicFilter)
        {
            Verify.NotNull(dynamicFilter, "dynamicFilter");

            InitializeComponent();

            filter = dynamicFilter;
            resetButton.Click += (sender, e) => HandleEvent(() => traceLevel.Checked = true);
        }
        public FilterByProcessId(DynamicFilterExpression dynamicFilter)
        {
            Verify.NotNull(dynamicFilter, "dynamicFilter");

            InitializeComponent();

            filter = dynamicFilter;
            resetButton.Click += (sender, e) => HandleEvent(ClearChecked);
        }
Exemple #13
0
        public Main()
        {
            InitializeComponent();

            bufferedItems = new List<ListViewItem>();
            mainToolStrip.Renderer = new CheckedButtonRenderer();
            splitContainer.Panel1MinSize = splitContainer.Panel2MinSize = 180;

            WireUpToolStrip();
            WireUpContextMenu();
            WireUpSystemEvents();

            accelerators = GetAccelerators();
            filter = new DynamicFilterExpression(Settings.GetFilter());
            flushBufferedItemsTimer = new Timer { Enabled = true, Interval = 100 };
            flushBufferedItemsTimer.Tick += (sender, e) => HandleEvent(FlushBufferedItems);
        }
        public FilterByText(DynamicFilterExpression dynamicFilter, String propertyName)
        {
            Verify.NotNull(dynamicFilter, "dynamicFilter");
            Verify.NotWhitespace(propertyName, "propertyName");
            Verify.True(dynamicFilter.HasProperty(propertyName), "propertyName", String.Format("Unknown '{0}' property specified: {1}", typeof(SystemEvent).Name, propertyName));

            InitializeComponent();

            filter = dynamicFilter;
            property = propertyName;

            addFilter.Click += (sender, e) => HandleEvent(AddFilter);
            clearFilter.Click += (sender, e) => HandleEvent(ClearFilter);
            resetButton.Click += (sender, e) => HandleEvent(ResetFilter);
            filters.KeyDown += (sender, e) => HandleEvent(() => { if (e.KeyCode == Keys.Delete) RemoveFilter(); e.Handled = true; });
            filterText.KeyDown += (sender, e) => HandleEvent(() => { if (e.KeyCode == Keys.Enter) addFilter.PerformClick(); e.Handled = true; });
        }
        public void ThrowExceptionIfUnknownFriendlyFilterName()
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { TextFilters = new[] { FilterDefinition.ForPositiveExpression("Source", "Unknown", "Some Value") } };

            Assert.Throws<ArgumentException>(() => dynamicFilter.Update());
        }
        public void SupportedFilterTypes(String friendlyName)
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { TextFilters = new[] { FilterDefinition.ForPositiveExpression("Source", friendlyName, "Some Value") } };

            Assert.DoesNotThrow(dynamicFilter.Update);
        }
        public void NeverReturnNull()
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter) { ProcessFilters = null };

            Assert.NotNull(dynamicFilter.ProcessFilters);
        }
        public void ReturnFalseIfNotSystemEventProperty()
        {
            var dynamicFilter = new DynamicFilterExpression(StaticFilter);

            Assert.False(dynamicFilter.HasProperty("DoesNotExist"));
        }