/*
    * 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 junit.framework.TestCase;
  import junit.framework.TestSuite;
  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;
   }
 }