/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//
// Log4j uses the JUnit framework for internal unit testing. JUnit
// available from
//
// http://www.junit.org
package org.apache.log4j.helpers;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.Logger;
import org.apache.log4j.Level;
import org.apache.log4j.helpers.BoundedFIFO;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.framework.TestFailure;
import junit.framework.Test;
/**
Unit test the {@link BoundedFIFO}.
@author Ceki Gülcü
@since 0.9.1 */
public class BoundedFIFOTestCase extends TestCase {
static Logger cat = Logger.getLogger("x");
static int MAX = 1000;
static LoggingEvent[] e = new LoggingEvent[MAX];
{
for (int i = 0; i < MAX; i++) {
e[i] = new LoggingEvent("", cat, Level.DEBUG, "e"+i, null);
}
}
public BoundedFIFOTestCase(String name) {
super(name);
}
public
void setUp() {
}
/**
Pattern: +++++..-----..
*/
public
void test1() {
for(int size = 1; size <= 128; size *=2) {
BoundedFIFO bf = new BoundedFIFO(size);
assertEquals(bf.getMaxSize(), size);
assertNull(bf.get());
int i;
int j;
int k;
for(i = 1; i < 2*size; i++) {
for(j = 0; j < i; j++) {
//System.out.println("Putting "+e[j]);
bf.put(e[j]); assertEquals(bf.length(), j < size ? j+1 : size);
}
int max = size < j ? size : j;
j--;
for(k = 0; k <= j; k++) {
//System.out.println("max="+max+", j="+j+", k="+k);
assertEquals(bf.length(), max - k > 0 ? max - k : 0);
Object r = bf.get();
//System.out.println("Got "+r);
if(k >= size)
assertNull(r);
else
assertEquals(r, e[k]);
}
}
//System.out.println("Passed size="+size);
}
}
/**
Pattern: ++++--++--++
*/
public
void test2() {
int size = 3;
BoundedFIFO bf = new BoundedFIFO(size);
bf.put(e[0]);
assertEquals(bf.get(), e[0]);
assertNull(bf.get());
bf.put(e[1]); assertEquals(bf.length(), 1);
bf.put(e[2]); assertEquals(bf.length(), 2);
bf.put(e[3]); assertEquals(bf.length(), 3);
assertEquals(bf.get(), e[1]); assertEquals(bf.length(), 2);
assertEquals(bf.get(), e[2]); assertEquals(bf.length(), 1);
assertEquals(bf.get(), e[3]); assertEquals(bf.length(), 0);
assertNull(bf.get()); assertEquals(bf.length(), 0);
}
int min(int a, int b) {
return a < b ? a : b;
}
/**
Pattern ++++++++++++++++++++ (insert only);
*/
public
void testResize1() {
int size = 10;
for(int n = 1; n < size*2; n++) {
for(int i = 0; i < size*2; i++) {
BoundedFIFO bf = new BoundedFIFO(size);
for(int f = 0; f < i; f++) {
bf.put(e[f]);
}
bf.resize(n);
int expectedSize = min(n, min(i, size));
assertEquals(bf.length(), expectedSize);
for(int c = 0; c < expectedSize; c++) {
assertEquals(bf.get(), e[c]);
}
}
}
}
/**
Pattern ++...+ --...-
*/
public
void testResize2() {
int size = 10;
for(int n = 1; n < size*2; n++) {
for(int i = 0; i < size*2; i++) {
for(int d = 0; d < min(i,size); d++) {
BoundedFIFO bf = new BoundedFIFO(size);
for(int p = 0; p < i; p++) {
bf.put(e[p]);
}
for(int g = 0; g < d; g++) {
bf.get();
}
// x = the number of elems in
int x = bf.length();
bf.resize(n);
int expectedSize = min(n, x);
assertEquals(bf.length(), expectedSize);
for(int c = 0; c < expectedSize; c++) {
assertEquals(bf.get(), e[c+d]);
}
assertNull(bf.get());
}
}
}
}
/**
Pattern: i inserts, d deletes, r inserts
*/
public
void testResize3() {
int size = 10;
for(int n = 1; n < size*2; n++) {
for(int i = 0; i < size; i++) {
for(int d = 0; d < i; d++) {
for(int r = 0; r < d; r++) {
BoundedFIFO bf = new BoundedFIFO(size);
for(int p0 = 0; p0 < i; p0++)
bf.put(e[p0]);
for(int g = 0; g < d; g++)
bf.get();
for(int p1 = 0; p1 < r; p1++)
bf.put(e[i+p1]);
int x = bf.length();
bf.resize(n);
int expectedSize = min(n, x);
assertEquals(bf.length(), expectedSize);
for(int c = 0; c < expectedSize; c++) {
assertEquals(bf.get(), e[c+d]);
}
//assertNull(bf.get());
}
}
}
}
}
public
static
Test suite() {
TestSuite suite = new TestSuite();
suite.addTest(new BoundedFIFOTestCase("test1"));
suite.addTest(new BoundedFIFOTestCase("test2"));
suite.addTest(new BoundedFIFOTestCase("testResize1"));
suite.addTest(new BoundedFIFOTestCase("testResize2"));
suite.addTest(new BoundedFIFOTestCase("testResize3"));
return suite;
}
}