dev/core/test/com/google/gwt/dev/cfg/LibraryGroupTest.java

/*
 * Copyright 2013 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.cfg;

import com.google.gwt.dev.cfg.LibraryGroup.CollidingCompilationUnitException;
import com.google.gwt.dev.cfg.LibraryGroup.DuplicateLibraryNameException;
import com.google.gwt.dev.cfg.LibraryGroup.UnresolvedLibraryException;
import com.google.gwt.dev.javac.CompiledClass;
import com.google.gwt.dev.javac.MockCompilationUnit;
import com.google.gwt.dev.javac.MockCompiledClass;
import com.google.gwt.thirdparty.guava.common.collect.Lists;
import com.google.gwt.thirdparty.guava.common.collect.Sets;

import junit.framework.TestCase;

import java.util.Collection;
import java.util.List;
import java.util.Set;

/**
 * Tests for LibraryGroup.
 */
public class LibraryGroupTest extends TestCase {

  public void testCreateSubGroup() {
    LibraryGroup looseLibraryGroup = LibraryGroup.fromLibraries(Lists.<Library> newArrayList(
        new MockLibrary("LibraryA"), new MockLibrary("LibraryB"), new MockLibrary("LibraryC"),
        new MockLibrary("LibraryD")), true);

    assertEquals(4, looseLibraryGroup.getLibraries().size());

    LibraryGroup strictLibraryGroup =
        looseLibraryGroup.createSubgroup(Lists.newArrayList("LibraryA", "LibraryA", "LibraryC"));

    assertEquals(2, strictLibraryGroup.getLibraries().size());
  }

  public void testDuplicateLibraryNames() {
    // Create regular/super source libraries.
    MockLibrary fooLibrary = new MockLibrary("FooLibrary");
    MockLibrary alsoFooLibrary = new MockLibrary("FooLibrary");

    // Try but fail to stick them in a library group.
    try {
      LibraryGroup.fromLibraries(
          Lists.<Library> newArrayList(fooLibrary, alsoFooLibrary, fooLibrary), true);
      fail("library group construction sould have failed because of a library name collision.");
    } catch (DuplicateLibraryNameException e) {
      // Expected behavior.
    }
  }

  public void testGetCompilationUnitByTypeNamesSeesAllNested() {
    // Create a nested compilation units.
    MockCompilationUnit nestedTypeCompilationUnit =
        new MockCompilationUnit("com.google.gwt.user.Outer", "superblah") {
          @Override
          public Collection<CompiledClass> getCompiledClasses() {
            MockCompiledClass outerCompiledClass = new MockCompiledClass(null,
                "com/google/gwt/user/Outer", "com.google.gwt.user.Outer");
            MockCompiledClass innerCompiledClass = new MockCompiledClass(outerCompiledClass,
                "com/google/gwt/user/Outer$Inner", "com.google.gwt.user.Outer.Inner");
            return Lists.<CompiledClass> newArrayList(outerCompiledClass, innerCompiledClass);
          }
        };

    // Create the library.
    MockLibrary regularLibrary = new MockLibrary("LibraryA");
    regularLibrary.addCompilationUnit(nestedTypeCompilationUnit);

    // Stick it in a library group.
    LibraryGroup libraryGroup =
        LibraryGroup.fromLibraries(Lists.<Library> newArrayList(regularLibrary), true);

    // Shows that get by source or binary name works for nested types.
    assertEquals(nestedTypeCompilationUnit,
        libraryGroup.getCompilationUnitByTypeSourceName("com.google.gwt.user.Outer.Inner"));
    assertEquals(nestedTypeCompilationUnit,
        libraryGroup.getCompilationUnitByTypeBinaryName("com.google.gwt.user.Outer$Inner"));
  }

  public void testGetCompilationUnitTypeNamesSourceNamesSeesAll() {
    // Create regular/super source compilation units.
    MockCompilationUnit regularCompilationUnit =
        new MockCompilationUnit("com.google.gwt.Regular", "blah");
    MockCompilationUnit superSourceCompilationUnit =
        new MockCompilationUnit("com.google.gwt.Super", "blah");

    // Create regular/super source libraries.
    MockLibrary regularLibrary = new MockLibrary("LibraryA");
    regularLibrary.addCompilationUnit(regularCompilationUnit);
    MockLibrary superSourceLibrary = new MockLibrary("LibraryB");
    superSourceLibrary.addSuperSourceCompilationUnit(superSourceCompilationUnit);

    // Stick them in a library group.
    LibraryGroup libraryGroup = LibraryGroup.fromLibraries(
        Lists.<Library> newArrayList(regularLibrary, superSourceLibrary), true);

    // Show that getCompilationUnitTypeSourceNames sees both kinds of compilation units.
    assertEquals(libraryGroup.getCompilationUnitTypeSourceNames(),
        Sets.newHashSet("com.google.gwt.Regular", "com.google.gwt.Super"));
  }

  public void testGetReboundTypeSourceNames() {
    // Build a large random acyclic library graph.
    List<MockLibrary> libraries = MockLibrary.createRandomLibraryGraph(210, 3);
    // Stick the libraries into a library group.
    LibraryGroup libraryGroup = LibraryGroup.fromLibraries(libraries, true);

    // Insert a differently named rebound type into every library.
    Set<String> expectedReboundTypeSourceNames = Sets.newHashSet();
    for (Library library : libraries) {
      String reboundTypeSourceName = "Type" + System.identityHashCode(library);
      library.getReboundTypeSourceNames().add(reboundTypeSourceName);
      expectedReboundTypeSourceNames.add(reboundTypeSourceName);
    }

    // Show that the library group collects and returns them all.
    assertTrue(
        expectedReboundTypeSourceNames.equals(libraryGroup.getReboundTypeSourceNames()));
  }

  public void testLibraryLinkOrder() {
    // Build a large random acyclic library graph.
    List<MockLibrary> libraries = MockLibrary.createRandomLibraryGraph(210, 3);

    // Stick it in a LibraryGroup.
    LibraryGroup libraryGroup = LibraryGroup.fromLibraries(libraries, true);

    // Verify that each parent comes after all of its children after the LibraryGroup has performed
    // link ordering.
    List<Library> linkOrderLibraries = libraryGroup.getLibraries();
    for (Library parentLibrary : libraries) {
      int parentLibraryIndex = linkOrderLibraries.indexOf(parentLibrary);
      assertTrue(parentLibraryIndex != -1);
      Collection<Library> childLibraries =
          libraryGroup.getLibraries(parentLibrary.getDependencyLibraryNames());
      for (Library childLibrary : childLibraries) {
        int childLibraryIndex = linkOrderLibraries.indexOf(childLibrary);
        assertTrue(childLibraryIndex != -1);
        assertTrue(childLibraryIndex < parentLibraryIndex);
      }
    }
    assertEquals(libraries.size(), linkOrderLibraries.size());
  }

  public static LibraryGroup buildVariedPropertyGeneratorLibraryGroup(
      Set<String> reboundTypeSourceNamesOne, Set<String> reboundTypeSourceNamesTwo) {
    // A root library that adds more legal user.agent and locale values but for which no generators
    // have been run.
    MockLibrary rootLibrary = new MockLibrary("RootLibrary");
    rootLibrary.getDependencyLibraryNames().addAll(
        Lists.newArrayList("SubLibrary1", "SubLibrary2"));

    // A library that adds legal user.agent values and has already run the UserAgentAsserter
    // generator.
    MockLibrary subLibrary1 = new MockLibrary("SubLibrary1");
    subLibrary1.getReboundTypeSourceNames().addAll(reboundTypeSourceNamesOne);

    // A library that adds legal locale values and has already run the LocaleMessageGenerator
    // generator.
    MockLibrary subLibrary2 = new MockLibrary("SubLibrary2");
    subLibrary2.getReboundTypeSourceNames().addAll(reboundTypeSourceNamesTwo);

    LibraryGroup libraryGroup = LibraryGroup.fromLibraries(
        Lists.<Library> newArrayList(rootLibrary, subLibrary1, subLibrary2), true);
    return libraryGroup;
  }

  public void testEnforcesUniqueCompilationUnits() {
    MockCompilationUnit compilationUnit = new MockCompilationUnit("com.google.gwt.Regular", "blah");

    // Creates libraries with colliding compilation units.
    MockLibrary libraryA = new MockLibrary("LibraryA");
    libraryA.addCompilationUnit(compilationUnit);
    MockLibrary libraryB = new MockLibrary("LibraryB");
    libraryB.addCompilationUnit(compilationUnit);

    // Stick them in a library group.
    LibraryGroup libraryGroup =
        LibraryGroup.fromLibraries(Lists.<Library> newArrayList(libraryA, libraryB), true);

    // Show that the library group catches the duplication.
    try {
      libraryGroup.getCompilationUnitByTypeSourceName("com.google.gwt.Regular");
      fail("The library group should have detected and rejected the duplicate compilation unit.");
    } catch (CollidingCompilationUnitException e) {
      // expected behavior
    }
  }

  public void testUnresolvedLibraryReference() {
    // Create a library that references some library which is not available.
    MockLibrary library = new MockLibrary("RootLibrary");
    library.getDependencyLibraryNames().add("com.something.Missing");

    try {
      // Attempt to build a library group with strict library reference enforcement.
      LibraryGroup.fromLibraries(Lists.<Library> newArrayList(library), true);
      fail("Expected library group construction to fail on the missing referenced library.");
    } catch (UnresolvedLibraryException e) {
      // Expected behavior.
    }

    // Successfully build the library group when allowing missing references.
    LibraryGroup.fromLibraries(Lists.<Library> newArrayList(library), false);
  }
}