2.4/dev/core/test/com/google/gwt/dev/javac/PersistentUnitCacheTest.java

/*
 * Copyright 2011 Google Inc.
 * 
 * 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.gwt.dev.javac;

import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.dev.util.Util;

import junit.framework.TestCase;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * Unit test for {@link PersistentUnitCache}.
 */
public class PersistentUnitCacheTest extends TestCase {

  private static class ThrowsClassNotFoundException implements Serializable {
    @SuppressWarnings("unused")
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
      throw new ClassNotFoundException();
    }
  }

  private static class ThrowsIOException implements Serializable {
    @SuppressWarnings("unused")
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
      throw new IOException();
    }
  }

  File lastCacheDir = null;

  public void tearDown() {
    if (lastCacheDir != null) {
      Util.recursiveDelete(lastCacheDir, false);
    }
    lastCacheDir = null;
  }

  /**
   * When a cache file encounters a serialization error, the logic should assume
   * the cache log is stale and remove it.
   */
  public void testClassNotFoundException() throws IOException, UnableToCompleteException,
      InterruptedException {
    checkInvalidObjectInCache(new ThrowsClassNotFoundException());
  }

  /**
   * Test if a file already exists with the name we want to put the cache dir
   * in.
   */
  public void testFileInTheWay() throws IOException {
    TreeLogger logger = TreeLogger.NULL;
    File fileInTheWay = File.createTempFile("PersistentUnitTest-inTheWay", "");
    assertNotNull(fileInTheWay);
    assertTrue(fileInTheWay.exists());
    fileInTheWay.deleteOnExit();
    try {
      new PersistentUnitCache(logger, fileInTheWay);
      fail("Expected an exception to be thrown");
    } catch (UnableToCompleteException expected) {
    }
  }

  /**
   * If a cache file has some kind of IO exception, (this can happen with a
   * stale cache file), then the exception should be ignored and the cache file
   * removed.
   */
  public void testIOException() throws IOException, UnableToCompleteException, InterruptedException {
    checkInvalidObjectInCache(new ThrowsIOException());
  }

  /**
   * The cache should recursively create the directories it needs.
   */
  public void testNewDir() throws IOException, UnableToCompleteException {
    TreeLogger logger = TreeLogger.NULL;
    File baseDir = File.createTempFile("PersistentUnitTest-newDir", "");
    assertNotNull(baseDir);
    assertTrue(baseDir.exists());
    assertTrue(baseDir.delete());
    File newDir = lastCacheDir = new File(baseDir, "sHoUlDnOtExi57");
    new PersistentUnitCache(logger, newDir);
    assertTrue(newDir.isDirectory());
  }

  public void testPersistentCache() throws IOException, InterruptedException,
      UnableToCompleteException {
    TreeLogger logger = TreeLogger.NULL;

    File cacheDir = lastCacheDir = File.createTempFile("persistentCacheTest", "");
    File unitCacheDir = mkCacheDir(cacheDir);

    PersistentUnitCache cache = new PersistentUnitCache(logger, cacheDir);

    MockCompilationUnit foo1 = new MockCompilationUnit("com.example.Foo", "Foo: source1");
    cache.add(foo1);
    MockCompilationUnit bar1 = new MockCompilationUnit("com.example.Bar", "Bar: source1");
    cache.add(bar1);
    CompilationUnit result;

    // Find by content Id
    result = cache.find(foo1.getContentId());
    assertNotNull(result);
    assertEquals("com.example.Foo", result.getTypeName());
    result = cache.find(bar1.getContentId());
    assertNotNull(result);
    assertEquals("com.example.Bar", result.getTypeName());

    // Find by type name
    result = cache.find("com/example/Foo.java");
    assertNotNull(result);
    assertEquals("com.example.Foo", result.getTypeName());
    result = cache.find("com/example/Bar.java");
    assertNotNull(result);
    assertEquals("com.example.Bar", result.getTypeName());

    // Replace Foo with a new version
    MockCompilationUnit foo2 = new MockCompilationUnit("com.example.Foo", "Foo: source2");
    cache.add(foo2);
    result = cache.find(foo1.getContentId());
    assertNull(result);
    result = cache.find(foo2.getContentId());
    assertNotNull(result);
    assertEquals("com.example.Foo", result.getTypeName());
    result = cache.find("com/example/Foo.java");
    assertNotNull(result);
    assertEquals("com.example.Foo", result.getTypeName());
    assertEquals(foo2.getContentId(), result.getContentId());
    cache.cleanup(logger);

    // Shutdown the cache and re -load it
    cache.shutdown();

    // There should be a single file in the cache dir.
    assertNumCacheFiles(unitCacheDir, 1);

    // Fire up the cache again. It be pre-populated.
    // Search by type name
    cache = new PersistentUnitCache(logger, cacheDir);
    result = cache.find("com/example/Foo.java");
    assertNotNull(result);
    assertEquals("com.example.Foo", result.getTypeName());
    assertEquals(foo2.getContentId(), result.getContentId());
    result = cache.find("com/example/Bar.java");
    assertNotNull(result);
    assertEquals("com.example.Bar", result.getTypeName());
    assertEquals(bar1.getContentId(), result.getContentId());

    // Search by Content ID.
    // old version of Foo should not be there.
    result = cache.find(foo1.getContentId());
    assertNull(result);
    result = cache.find(bar1.getContentId());
    assertNotNull(result);
    assertEquals(bar1.getTypeName(), result.getTypeName());
    assertEquals(bar1.getContentId(), result.getContentId());
    result = cache.find(foo2.getContentId());
    assertNotNull(result);
    assertEquals(foo2.getTypeName(), result.getTypeName());
    assertEquals(foo2.getContentId(), result.getContentId());
    cache.cleanup(logger);

    // We didn't write anything, still 1 file.
    cache.shutdown();
    assertNumCacheFiles(unitCacheDir, 1);

    // keep making more files
    MockCompilationUnit lastUnit = null;
    assertTrue(PersistentUnitCache.CACHE_FILE_THRESHOLD > 3);
    for (int i = 2; i < PersistentUnitCache.CACHE_FILE_THRESHOLD; ++i) {
      cache = new PersistentUnitCache(logger, cacheDir);
      lastUnit = new MockCompilationUnit("com.example.Foo", "Foo Source" + i);
      cache.add(lastUnit);
      cache.cleanup(logger);
      cache.shutdown();
      assertNumCacheFiles(unitCacheDir, i);
    }

    // One last check, we should load the last unit added to the cache.
    cache = new PersistentUnitCache(logger, cacheDir);
    result = cache.find(lastUnit.getContentId());
    assertNotNull(result);
    assertEquals("com.example.Foo", result.getTypeName());
    assertEquals(lastUnit.getContentId(), result.getContentId());

    result = cache.find(bar1.getContentId());
    assertNotNull(result);
    assertEquals("com.example.Bar", result.getTypeName());
    assertEquals(bar1.getContentId(), result.getContentId());

    result = cache.find("com/example/Foo.java");
    assertNotNull(result);
    assertEquals("com.example.Foo", result.getTypeName());
    assertEquals(lastUnit.getContentId(), result.getContentId());

    result = cache.find("com/example/Bar.java");
    assertNotNull(result);
    assertEquals("com.example.Bar", result.getTypeName());
    assertEquals(bar1.getContentId(), result.getContentId());

    lastUnit = new MockCompilationUnit("com.example.Foo", "Foo Source");
    cache.add(lastUnit);

    // This time, the cleanup logic should coalesce the logs into one file
    // again.
    cache.cleanup(logger);
    cache.shutdown();
    assertNumCacheFiles(unitCacheDir, 1);
  }

  private void assertNumCacheFiles(File unitCacheDir, int expected) {
    assertEquals(expected, unitCacheDir.list().length);
  }

  private void checkInvalidObjectInCache(Object toSerialize) throws IOException,
      FileNotFoundException, UnableToCompleteException, InterruptedException {
    TreeLogger logger = TreeLogger.NULL;
    File cacheDir = lastCacheDir = File.createTempFile("PersistentUnitTest-CNF", "");
    File unitCacheDir = mkCacheDir(cacheDir);

    /*
     * Create a cache file that has the right filename, but the wrong kind of
     * object in it.
     */
    File errorFile = new File(unitCacheDir, PersistentUnitCache.CACHE_FILE_PREFIX + "12345");
    ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(errorFile));
    os.writeObject(toSerialize);
    os.close();

    assertNumCacheFiles(unitCacheDir, 1);

    PersistentUnitCache cache = new PersistentUnitCache(logger, cacheDir);
    cache.cleanup(logger);
    cache.shutdown();

    // The bogus file should have been removed.
    assertNumCacheFiles(unitCacheDir, 0);
  }

  private File mkCacheDir(File cacheDir) {
    assertNotNull(cacheDir);
    assertTrue(cacheDir.exists());
    cacheDir.delete();
    File unitCacheDir = new File(cacheDir, PersistentUnitCache.UNIT_CACHE_PREFIX);
    unitCacheDir.mkdirs();
    return unitCacheDir;
  }
}