/*
    * Copyright (C) 2011 The Guava Authors
    *
    * Licensed 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.
   */
  
  package com.google.common.util.concurrent;
  
  import static com.google.common.collect.Iterables.concat;
  
  import com.google.common.base.Functions;
  import com.google.common.base.Supplier;
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.Lists;
  import com.google.common.collect.Maps;
  import com.google.common.collect.Ordering;
  import com.google.common.collect.Sets;
  import com.google.common.testing.GcFinalization;
  import com.google.common.testing.NullPointerTester;
  
  import junit.framework.TestCase;
  
  import java.lang.ref.WeakReference;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.Semaphore;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReadWriteLock;
  import java.util.concurrent.locks.ReentrantLock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  /**
   * Tests for Striped.
   *
   * @author Dimitris Andreou
   */
  public class StripedTest extends TestCase {
    private static List<Striped<?>> strongImplementations() {
      return ImmutableList.of(
          Striped.readWriteLock(100),
          Striped.readWriteLock(256),
          Striped.lock(100),
          Striped.lock(256),
          Striped.semaphore(100, 1),
          Striped.semaphore(256, 1));
    }
  
    private static final Supplier<ReadWriteLock> READ_WRITE_LOCK_SUPPLIER =
        new Supplier<ReadWriteLock>() {
      @Override public ReadWriteLock get() {
        return new ReentrantReadWriteLock();
      }
    };
  
    private static final Supplier<Lock> LOCK_SUPPLER = new Supplier<Lock>() {
      @Override public Lock get() {
        return new ReentrantLock();
      }
    };
  
    private static final Supplier<Semaphore> SEMAPHORE_SUPPLER = new Supplier<Semaphore>() {
      @Override public Semaphore get() {
        return new Semaphore(1, false);
      }
    };
  
    private static List<Striped<?>> weakImplementations() {
      return ImmutableList.<Striped<?>>builder()
          .add(new Striped.SmallLazyStriped<ReadWriteLock>(50, READ_WRITE_LOCK_SUPPLIER))
          .add(new Striped.SmallLazyStriped<ReadWriteLock>(64, READ_WRITE_LOCK_SUPPLIER))
          .add(new Striped.LargeLazyStriped<ReadWriteLock>(50, READ_WRITE_LOCK_SUPPLIER))
          .add(new Striped.LargeLazyStriped<ReadWriteLock>(64, READ_WRITE_LOCK_SUPPLIER))
          .add(new Striped.SmallLazyStriped<Lock>(50, LOCK_SUPPLER))
          .add(new Striped.SmallLazyStriped<Lock>(64, LOCK_SUPPLER))
          .add(new Striped.LargeLazyStriped<Lock>(50, LOCK_SUPPLER))
          .add(new Striped.LargeLazyStriped<Lock>(64, LOCK_SUPPLER))
          .add(new Striped.SmallLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))
          .add(new Striped.SmallLazyStriped<Semaphore>(64, SEMAPHORE_SUPPLER))
          .add(new Striped.LargeLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))
          .add(new Striped.LargeLazyStriped<Semaphore>(64, SEMAPHORE_SUPPLER))
          .build();
    }
  
    private static Iterable<Striped<?>> allImplementations() {
      return concat(strongImplementations(), weakImplementations());
    }
  
    public void testNull() throws Exception {
     for (Striped<?> striped : allImplementations()) {
       new NullPointerTester().testAllPublicInstanceMethods(striped);
     }
   }
 
   public void testSizes() {
     // not bothering testing all variations, since we know they share implementations
     assertTrue(Striped.lock(100).size() >= 100);
     assertTrue(Striped.lock(256).size() == 256);
     assertTrue(Striped.lazyWeakLock(100).size() >= 100);
     assertTrue(Striped.lazyWeakLock(256).size() == 256);
   }
 
   public void testWeakImplementations() {
     for (Striped<?> striped : weakImplementations()) {
       WeakReference<Object> weakRef = new WeakReference<Object>(striped.get(new Object()));
       GcFinalization.awaitClear(weakRef);
     }
   }
 
   public void testStrongImplementations() {
     for (Striped<?> striped : strongImplementations()) {
       WeakReference<Object> weakRef = new WeakReference<Object>(striped.get(new Object()));
       WeakReference<Object> garbage = new WeakReference<Object>(new Object());
       GcFinalization.awaitClear(garbage);
       assertNotNull(weakRef.get());
     }
   }
 
   public void testMaximalWeakStripedLock() {
     Striped<Lock> stripedLock = Striped.lazyWeakLock(Integer.MAX_VALUE);
     for (int i = 0; i < 10000; i++) {
       stripedLock.get(new Object()).lock();
       // nothing special (e.g. an exception) happens
     }
   }
 
   public void testBulkGetReturnsSorted() {
     for (Striped<?> striped : allImplementations()) {
       Map<Object, Integer> indexByLock = Maps.newHashMap();
       for (int i = 0; i < striped.size(); i++) {
         indexByLock.put(striped.getAt(i), i);
       }
 
       // ensure that bulkGet returns locks in monotonically increasing order
       for (int objectsNum = 1; objectsNum <= striped.size() * 2; objectsNum++) {
         Set<Object> objects = Sets.newHashSetWithExpectedSize(objectsNum);
         for (int i = 0; i < objectsNum; i++) {
           objects.add(new Object());
         }
 
         Iterable<?> locks = striped.bulkGet(objects);
         assertTrue(Ordering.natural().onResultOf(Functions.forMap(indexByLock)).isOrdered(locks));
 
         // check idempotency
         Iterable<?> locks2 = striped.bulkGet(objects);
         assertEquals(Lists.newArrayList(locks), Lists.newArrayList(locks2));
       }
     }
   }
 
   /**
    * Checks idempotency, and that we observe the promised number of stripes.
    */
   public void testBasicInvariants() {
     for (Striped<?> striped : allImplementations()) {
       assertBasicInvariants(striped);
     }
   }
 
   private static void assertBasicInvariants(Striped<?> striped) {
     Set<Object> observed = Sets.newIdentityHashSet(); // for the sake of weakly referenced locks.
     // this gets the stripes with #getAt(index)
     for (int i = 0; i < striped.size(); i++) {
       Object object = striped.getAt(i);
       assertNotNull(object);
       assertSame(object, striped.getAt(i)); // idempotent
       observed.add(object);
     }
     assertTrue("All stripes observed", observed.size() == striped.size());
 
     // this uses #get(key), makes sure an already observed stripe is returned
     for (int i = 0; i < striped.size() * 100; i++) {
       assertTrue(observed.contains(striped.get(new Object())));
     }
 
     try {
       striped.getAt(-1);
       fail();
     } catch (RuntimeException expected) {}
 
     try {
       striped.getAt(striped.size());
       fail();
     } catch (RuntimeException expected) {}
   }
 
   public void testMaxSize() {
     for (Striped<?> striped : ImmutableList.of(
         Striped.lazyWeakLock(Integer.MAX_VALUE),
         Striped.lazyWeakSemaphore(Integer.MAX_VALUE, Integer.MAX_VALUE),
         Striped.lazyWeakReadWriteLock(Integer.MAX_VALUE))) {
       for (int i = 0; i < 3; i++) {
         // doesn't throw exception
         striped.getAt(Integer.MAX_VALUE - i);
       }
     }
   }
 }