@Test public void testRemoveFiltersFromComposite() { final Filter filter1 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter filter2 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter compositeFilter = CompositeFilter.createFilters(new Filter[]{filter1, filter2}); final Filter anotherFilter = ThresholdFilter.createFilter(Level.WARN, null, null); filterable.addFilter(compositeFilter); filterable.addFilter(anotherFilter); assertEquals(3, ((CompositeFilter) filterable.getFilter()).getFilters().size()); filterable.removeFilter(filter1); assertEquals(2, ((CompositeFilter) filterable.getFilter()).getFilters().size()); filterable.removeFilter(filter2); assertSame(anotherFilter, filterable.getFilter()); }
@Test public void testNoFilters() throws Exception { ctx = Configurator.initialize("Test1", "bad/log4j-nofilter.xml"); LogManager.getLogger("org.apache.test.TestConfigurator"); final Configuration config = ctx.getConfiguration(); assertNotNull("No configuration", config); assertEquals("Unexpected Configuration", "XMLConfigTest", config.getName()); final LoggerConfig lcfg = config.getLoggerConfig("org.apache.logging.log4j.test1"); assertNotNull("No Logger", lcfg); final Filter filter = lcfg.getFilter(); assertNotNull("No Filter", filter); assertThat(filter, instanceOf(CompositeFilter.class)); assertTrue("Unexpected filters", ((CompositeFilter) filter).isEmpty()); }
@Test public void testAddCompositeFilter() throws Exception { final Filter filter1 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter filter2 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter compositeFilter = CompositeFilter.createFilters(new Filter[] {filter1, filter2}); filterable.addFilter(compositeFilter); assertSame(compositeFilter, filterable.getFilter()); }
/** * Adds a filter. * @param filter The Filter to add. */ @Override public synchronized void addFilter(final Filter filter) { if (filter == null) { return; } if (this.filter == null) { this.filter = filter; } else if (this.filter instanceof CompositeFilter) { this.filter = ((CompositeFilter) this.filter).addFilter(filter); } else { final Filter[] filters = new Filter[] {this.filter, filter}; this.filter = CompositeFilter.createFilters(filters); } }
/** * Removes a Filter. * @param filter The Filter to remove. */ @Override public synchronized void removeFilter(final Filter filter) { if (this.filter == null || filter == null) { return; } if (this.filter == filter || this.filter.equals(filter)) { this.filter = null; } else if (this.filter instanceof CompositeFilter) { CompositeFilter composite = (CompositeFilter) this.filter; composite = composite.removeFilter(filter); if (composite.size() > 1) { this.filter = composite; } else if (composite.size() == 1) { final Iterator<Filter> iter = composite.iterator(); this.filter = iter.next(); } else { this.filter = null; } } }
@Override public void start() { this.setStarting(); for (final Filter filter : filters) { filter.start(); } this.setStarted(); }
public CompositeFilter addFilter(final Filter filter) { if (filter == null) { // null does nothing return this; } if (filter instanceof CompositeFilter) { final int size = this.filters.length + ((CompositeFilter) filter).size(); final Filter[] copy = Arrays.copyOf(this.filters, size); final int index = this.filters.length; for (final Filter currentFilter : ((CompositeFilter) filter).filters) { copy[index] = currentFilter; } return new CompositeFilter(copy); } final Filter[] copy = Arrays.copyOf(this.filters, this.filters.length + 1); copy[this.filters.length] = filter; return new CompositeFilter(copy); }
@Test public void testAddMultipleSimpleFilters() throws Exception { final Filter filter = ThresholdFilter.createFilter(Level.ERROR, null, null); filterable.addFilter(filter); assertSame(filter, filterable.getFilter()); // adding a second filter converts the filter // into a CompositeFilter.class filterable.addFilter(filter); assertTrue(filterable.getFilter() instanceof CompositeFilter); assertEquals(2, ((CompositeFilter) filterable.getFilter()).getFilters().size()); }
public CompositeFilter removeFilter(final Filter filter) { if (filter == null) { // null does nothing return this; } // This is not a great implementation but simpler than copying Apache Commons // Lang ArrayUtils.removeElement() and associated bits (MutableInt), // which is OK since removing a filter should not be on the critical path. final List<Filter> filterList = new ArrayList<>(Arrays.asList(this.filters)); if (filter instanceof CompositeFilter) { for (final Filter currentFilter : ((CompositeFilter) filter).filters) { filterList.remove(currentFilter); } } else { filterList.remove(filter); } return new CompositeFilter(filterList.toArray(new Filter[this.filters.length - 1])); }
@Test public void testConfiguration() { final Configuration configuration = context.getConfiguration(); assertNotNull(configuration); final FileAppender appender = configuration.getAppender("info"); assertNotNull(appender); final CompositeFilter compFilter = (CompositeFilter) appender.getFilter(); assertNotNull(compFilter); final Filter[] filters = compFilter.getFiltersArray(); assertNotNull(filters); boolean foundLevel = false; for (final Filter filter : filters) { final ThresholdFilter tFilter = (ThresholdFilter) filter; if (infom1Level.equals(tFilter.getLevel())) { foundLevel = true; break; } } Assert.assertTrue("Level not found: " + infom1Level, foundLevel); }
/** * This method is not exposed through the public API and is used primarily for unit testing. * * @return An Iterator over all the Filters associated with the Logger. */ // FIXME: this really ought to be an Iterable instead of an Iterator public Iterator<Filter> getFilters() { final Filter filter = privateConfig.loggerConfig.getFilter(); if (filter == null) { return new ArrayList<Filter>().iterator(); } else if (filter instanceof CompositeFilter) { return ((CompositeFilter) filter).iterator(); } else { final List<Filter> filters = new ArrayList<>(); filters.add(filter); return filters.iterator(); } }
@Test public void testRemoveCompositeFilterFromCompositeFilter() { final Filter filter1 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter filter2 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter compositeFilter = CompositeFilter.createFilters(new Filter[]{filter1, filter2}); filterable.addFilter(compositeFilter); filterable.removeFilter(compositeFilter); assertNull(filterable.getFilter()); }
@Test public void testAddMultipleEqualSimpleFilter() throws Exception { final Filter filter = new EqualFilter("test"); filterable.addFilter(filter); assertSame(filter, filterable.getFilter()); // adding a second filter converts the filter // into a CompositeFilter.class filterable.addFilter(filter); assertTrue(filterable.getFilter() instanceof CompositeFilter); assertEquals(2, ((CompositeFilter) filterable.getFilter()).getFilters().size()); }
/** * Create a CompositeFilter. * * @param filters * An array of Filters to call. * @return The CompositeFilter. */ @PluginFactory public static CompositeFilter createFilters(@PluginElement("Filters") final Filter[] filters) { return new CompositeFilter(filters); }
@Test public void testRemoveSimpleFilterFromCompositeAndSimpleFilter() { final Filter filter1 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter filter2 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter compositeFilter = CompositeFilter.createFilters(new Filter[]{filter1, filter2}); final Filter anotherFilter = ThresholdFilter.createFilter(Level.WARN, null, null); filterable.addFilter(compositeFilter); filterable.addFilter(anotherFilter); // should not remove internal filter of compositeFilter filterable.removeFilter(anotherFilter); assertTrue(filterable.getFilter() instanceof CompositeFilter); assertEquals(2, ((CompositeFilter) filterable.getFilter()).getFilters().size()); }
@Test public void testRemoveSimpleFilterFromCompositeFilter() { final Filter filter1 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter filter2 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter compositeFilter = CompositeFilter.createFilters(new Filter[]{filter1, filter2}); filterable.addFilter(compositeFilter); // should remove internal filter of compositeFilter filterable.removeFilter(filter1); assertFalse(filterable.getFilter() instanceof CompositeFilter); assertEquals(filter2, filterable.getFilter()); }
@Test public void testRemoveSimpleEqualFilterFromMultipleSimpleFilters() throws Exception { final Filter filterOriginal = new EqualFilter("test"); final Filter filterCopy = new EqualFilter("test"); filterable.addFilter(filterOriginal); filterable.addFilter(filterOriginal); filterable.addFilter(filterCopy); filterable.removeFilter(filterCopy); assertTrue(filterable.getFilter() instanceof CompositeFilter); assertEquals(2, ((CompositeFilter) filterable.getFilter()).getFilters().size()); filterable.removeFilter(filterCopy); assertEquals(filterOriginal, filterable.getFilter()); filterable.removeFilter(filterOriginal); assertNull(filterable.getFilter()); }
@Test public void testAddMultipleCompositeFilters() throws Exception { final Filter filter1 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter filter2 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter filter3 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter compositeFilter = CompositeFilter.createFilters(new Filter[]{filter1, filter2, filter3}); filterable.addFilter(compositeFilter); assertSame(compositeFilter, filterable.getFilter()); // adding a second filter converts the filter // into a CompositeFilter.class filterable.addFilter(compositeFilter); assertTrue(filterable.getFilter() instanceof CompositeFilter); assertEquals(6, ((CompositeFilter) filterable.getFilter()).getFilters().size()); }
@Test public void testAddSimpleFilterAndCompositeFilter() throws Exception { final Filter filter1 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter filter2 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter notInCompositeFilterFilter = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter compositeFilter = CompositeFilter.createFilters(new Filter[]{filter1, filter2}); filterable.addFilter(notInCompositeFilterFilter); assertSame(notInCompositeFilterFilter, filterable.getFilter()); // adding a second filter converts the filter // into a CompositeFilter.class filterable.addFilter(compositeFilter); assertTrue(filterable.getFilter() instanceof CompositeFilter); assertEquals(2, ((CompositeFilter) filterable.getFilter()).getFilters().size()); }
@Test public void testAddCompositeFilterAndSimpleFilter() throws Exception { final Filter filter1 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter filter2 = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter notInCompositeFilterFilter = ThresholdFilter.createFilter(Level.ERROR, null, null); final Filter compositeFilter = CompositeFilter.createFilters(new Filter[]{filter1, filter2}); filterable.addFilter(compositeFilter); assertSame(compositeFilter, filterable.getFilter()); // adding a second filter converts the filter // into a CompositeFilter.class filterable.addFilter(notInCompositeFilterFilter); assertTrue(filterable.getFilter() instanceof CompositeFilter); assertEquals(3, ((CompositeFilter) filterable.getFilter()).getFilters().size()); }