TestLinkerDef.java

/*
 * #%L
 * Native ARchive plugin for Maven
 * %%
 * Copyright (C) 2002 - 2014 NAR Maven Plugin developers.
 * %%
 * 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.
 * #L%
 */
package com.github.maven_nar.cpptasks;

import java.io.File;
import java.io.IOException;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.types.FlexInteger;
import org.apache.tools.ant.types.Reference;

import com.github.maven_nar.cpptasks.compiler.CommandLineLinkerConfiguration;
import com.github.maven_nar.cpptasks.compiler.Linker;
import com.github.maven_nar.cpptasks.gcc.GccLinker;
import com.github.maven_nar.cpptasks.msvc.MsvcLinker;
import com.github.maven_nar.cpptasks.types.FlexLong;
import com.github.maven_nar.cpptasks.types.LibrarySet;
import com.github.maven_nar.cpptasks.types.LinkerArgument;
import com.github.maven_nar.cpptasks.types.SystemLibrarySet;

/**
 * Tests for LinkerDef class.
 */
public final class TestLinkerDef extends TestProcessorDef {
  /**
   * Sets the name attribute.
   *
   * @param linker
   *          linker defintion
   * @param name
   *          linker name
   */
  private static void setLinkerName(final LinkerDef linker, final String name) {
    final LinkerEnum linkerName = new LinkerEnum();
    linkerName.setValue(name);
    linker.setName(linkerName);
  }

  /**
   * Constructor.
   *
   * @param name
   *          test name
   */
  public TestLinkerDef(final String name) {
    super(name);
  }

  /**
   * Creates a processor.
   *
   * @return new linker
   */
  @Override
  protected ProcessorDef create() {
    return new LinkerDef();
  }

  /**
   * Gets the command line arguments that appear before the filenames.
   *
   * @param processor
   *          processor under test
   * @return command line arguments
   */
  @Override
  protected String[] getPreArguments(final ProcessorDef processor) {
    return ((CommandLineLinkerConfiguration) getConfiguration(processor)).getPreArguments();
  }

  /**
   * Tests that the base attribute in the base linker is effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsBase() {
    final LinkerDef baseLinker = new LinkerDef();
    baseLinker.setBase(new FlexLong("10000"));
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    setLinkerName(extendedLinker, "msvc");
    final String[] preArgs = getPreArguments(extendedLinker);
    assertEquals("/NOLOGO", preArgs[0]);
    assertEquals("/SUBSYSTEM:WINDOWS", preArgs[1]);
    assertEquals("/INCREMENTAL:NO", preArgs[2]);
    assertEquals("/BASE:0x2710", preArgs[3]);
  }

  /**
   * Tests that the classname attribute in the base linker is effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsClassname() {
    final LinkerDef baseLinker = new LinkerDef();
    baseLinker.setClassname("com.github.maven_nar.cpptasks.msvc.MsvcLinker");
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    extendedLinker.setBase(new FlexLong("10000"));
    final String[] preArgs = getPreArguments(extendedLinker);
    assertEquals("/NOLOGO", preArgs[0]);
    assertEquals("/SUBSYSTEM:WINDOWS", preArgs[1]);
    assertEquals("/INCREMENTAL:NO", preArgs[2]);
    assertEquals("/BASE:0x2710", preArgs[3]);
  }

  /**
   * Tests that the entry attribute in the base linker is effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsEntry() {
    final LinkerDef baseLinker = new LinkerDef();
    baseLinker.setEntry("foo");
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    final String[] preArgs = getPreArguments(extendedLinker);
    assertEquals("-e", preArgs[0]);
    assertEquals("foo", preArgs[1]);
  }

  /**
   * Tests that fileset's that appear in the base linker are effective when
   * creating the command line for a linker that extends it.
   * 
   * @throws IOException
   *           if unable to create or delete temporary file
   */
  public void testExtendsFileSet() throws IOException {
    super.testExtendsFileSet(File.createTempFile("cpptaskstest", ".o"));
  }

  /**
   * Tests that the fixed attribute in the base linker is effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsFixed() {
    final LinkerDef baseLinker = new LinkerDef();
    baseLinker.setFixed(true);
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    setLinkerName(extendedLinker, "msvc");
    final String[] preArgs = getPreArguments(extendedLinker);
    assertEquals("/NOLOGO", preArgs[0]);
    assertEquals("/SUBSYSTEM:WINDOWS", preArgs[1]);
    assertEquals("/INCREMENTAL:NO", preArgs[2]);
    assertEquals("/FIXED", preArgs[3]);
  }

  /**
   * Tests that the incremental attribute in the base linker is effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsIncremental() {
    final LinkerDef baseLinker = new LinkerDef();
    baseLinker.setIncremental(true);
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    setLinkerName(extendedLinker, "msvc");
    final String[] preArgs = getPreArguments(extendedLinker);
    assertEquals("/NOLOGO", preArgs[0]);
    assertEquals("/SUBSYSTEM:WINDOWS", preArgs[1]);
    assertEquals("/INCREMENTAL:YES", preArgs[2]);
  }

  /**
   * Tests that libset's that appear in the base linker are effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsLibSet() {
    final LinkerDef baseLinker = new LinkerDef();
    final LibrarySet libset = new LibrarySet();
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    libset.setProject(baseLinker.getProject());
    final CUtil.StringArrayBuilder libs = new CUtil.StringArrayBuilder("advapi32");
    libset.setLibs(libs);
    baseLinker.addLibset(libset);
    final CommandLineLinkerConfiguration config = (CommandLineLinkerConfiguration) getConfiguration(extendedLinker);
    final String[] libnames = config.getLibraryNames();
    assertEquals(1, libnames.length);
    assertEquals("advapi32", libnames[0]);
  }

  /**
   * Tests that linkerarg's that appear in the base linker are effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsLinkerArgs() {
    final LinkerDef baseLinker = new LinkerDef();
    final LinkerArgument linkerArg = new LinkerArgument();
    linkerArg.setValue("/base");
    baseLinker.addConfiguredLinkerArg(linkerArg);
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    final String[] preArgs = getPreArguments(extendedLinker);
    assertEquals(1, preArgs.length);
    assertEquals("/base", preArgs[0]);
  }

  /**
   * Verify linkerarg's that appear in the base linker are effective when
   * creating the command line for a linker that extends it, even if the
   * linker is brought in through a reference.
   */
  public void testExtendsLinkerArgsViaReference() {
    final Project project = new Project();
    final LinkerDef baseLinker = new LinkerDef();
    baseLinker.setProject(project);
    baseLinker.setId("base");
    project.addReference("base", baseLinker);
    final LinkerArgument linkerArg = new LinkerArgument();
    linkerArg.setValue("/base");
    baseLinker.addConfiguredLinkerArg(linkerArg);

    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    extendedLinker.setProject(project);
    extendedLinker.setId("extended");
    project.addReference("extended", extendedLinker);

    final LinkerDef linkerRef = new LinkerDef();
    linkerRef.setProject(project);
    linkerRef.setRefid(new Reference(project, "extended"));
    final String[] preArgs = getPreArguments(linkerRef);
    assertEquals(1, preArgs.length);
    assertEquals("/base", preArgs[0]);
  }

  /**
   * Tests that the map attribute in the base linker is effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsMap() {
    final LinkerDef baseLinker = new LinkerDef();
    baseLinker.setMap(true);
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    setLinkerName(extendedLinker, "msvc");
    final String[] preArgs = getPreArguments(extendedLinker);
    assertEquals("/NOLOGO", preArgs[0]);
    assertEquals("/SUBSYSTEM:WINDOWS", preArgs[1]);
    assertEquals("/INCREMENTAL:NO", preArgs[2]);
    assertEquals("/MAP", preArgs[3]);
  }

  /**
   * Tests that the name attribute in the base linker is effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsName() {
    final LinkerDef baseLinker = new LinkerDef();
    setLinkerName(baseLinker, "msvc");
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    extendedLinker.setBase(new FlexLong("10000"));
    final String[] preArgs = getPreArguments(extendedLinker);
    assertEquals("/NOLOGO", preArgs[0]);
    assertEquals("/SUBSYSTEM:WINDOWS", preArgs[1]);
    assertEquals("/INCREMENTAL:NO", preArgs[2]);
    assertEquals("/BASE:0x2710", preArgs[3]);
  }

  /**
   * Tests that the rebuild attribute in the base linker is effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsRebuild() {
    testExtendsRebuild(new LinkerDef());
  }

  /**
   * Tests that the stack attribute in the base linker is effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsStack() {
    final LinkerDef baseLinker = new LinkerDef();
    baseLinker.setStack(new FlexInteger("10000"));
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    setLinkerName(extendedLinker, "msvc");
    final String[] preArgs = getPreArguments(extendedLinker);
    assertEquals("/NOLOGO", preArgs[0]);
    assertEquals("/SUBSYSTEM:WINDOWS", preArgs[1]);
    assertEquals("/INCREMENTAL:NO", preArgs[2]);
    assertEquals("/STACK:0x2710", preArgs[3]);
  }

  /**
   * Tests that syslibset's that appear in the base linker are effective when
   * creating the command line for a linker that extends it.
   */
  public void testExtendsSysLibSet() {
    final LinkerDef baseLinker = new LinkerDef();
    final SystemLibrarySet libset = new SystemLibrarySet();
    final LinkerDef extendedLinker = (LinkerDef) createExtendedProcessorDef(baseLinker);
    libset.setProject(baseLinker.getProject());
    final CUtil.StringArrayBuilder libs = new CUtil.StringArrayBuilder("advapi32");
    libset.setLibs(libs);
    baseLinker.addSyslibset(libset);
    final CommandLineLinkerConfiguration config = (CommandLineLinkerConfiguration) getConfiguration(extendedLinker);
    final String[] libnames = config.getLibraryNames();
    assertEquals(1, libnames.length);
    assertEquals("advapi32", libnames[0]);
  }

  /**
   * Test if setting the classname attribute to the name of the GCC linker
   * results in the singleton GCC linker.
   */
  public void testGetGcc() {
    final LinkerDef linkerDef = (LinkerDef) create();
    linkerDef.setClassname("com.github.maven_nar.cpptasks.gcc.GccLinker");
    final Linker comp = (Linker) linkerDef.getProcessor();
    assertNotNull(comp);
    assertSame(GccLinker.getInstance(), comp);
  }

  /**
   * Test if setting the classname attribute to the name of the MSVC linker
   * results in the singleton MSVC linker.
   */
  public void testGetMSVC() {
    final LinkerDef linkerDef = (LinkerDef) create();
    linkerDef.setClassname("com.github.maven_nar.cpptasks.msvc.MsvcLinker");
    final Linker comp = (Linker) linkerDef.getProcessor();
    assertNotNull(comp);
    assertSame(MsvcLinker.getInstance(), comp);
  }

  /**
   * Tests if setting the classname attribute to an bogus classname results in
   * a BuildException.
   *
   */
  public void testUnknownClass() {
    final LinkerDef linkerDef = (LinkerDef) create();
    try {
      linkerDef.setClassname("com.github.maven_nar.cpptasks.bogus.BogusLinker");
    } catch (final BuildException ex) {
      return;
    }
    fail("should have thrown exception");
  }

  /**
   * Tests if setting the classname to the name of a class that doesn't
   * support Linker throws a BuildException.
   *
   */
  public void testWrongType() {
    final LinkerDef linkerDef = (LinkerDef) create();
    try {
      linkerDef.setClassname("com.github.maven_nar.cpptasks.CCTask");
    } catch (final ClassCastException ex) {
      return;
    }
    fail("should have thrown exception");
  }
  /**
   * Tests the behavior of testExcludeOptions,
   * ensures that linker arguments are removed as expected.
   */
  public void testLinkerBase() {
    final LinkerDef baseLinkerDef = new LinkerDef();
    final LinkerArgument argument1 = new LinkerArgument();
    argument1.setValue("OPTION1");
    baseLinkerDef.addConfiguredLinkerArg(argument1);
    final LinkerArgument argument2 = new LinkerArgument();
    argument2.setValue("OPTION2");
    baseLinkerDef.addConfiguredLinkerArg(argument2);
    assertEquals(2,baseLinkerDef.getProcessorArgs().size());
    baseLinkerDef.removeConfiguredLinkerArg(argument1);
    baseLinkerDef.removeConfiguredLinkerArg(argument2);
    assertEquals(0,baseLinkerDef.getProcessorArgs().size());
  }
}