/*
    * #%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 com.github.maven_nar.cpptasks.compiler.CommandLineCompilerConfiguration;
  import com.github.maven_nar.cpptasks.compiler.Compiler;
  import com.github.maven_nar.cpptasks.compiler.LinkType;
  import com.github.maven_nar.cpptasks.gcc.GccCCompiler;
  import com.github.maven_nar.cpptasks.msvc.MsvcCCompiler;
  import com.github.maven_nar.cpptasks.types.CompilerArgument;
  import com.github.maven_nar.cpptasks.types.ConditionalPath;
  import com.github.maven_nar.cpptasks.types.DefineArgument;
  import com.github.maven_nar.cpptasks.types.DefineSet;
  import com.github.maven_nar.cpptasks.types.IncludePath;
  import com.github.maven_nar.cpptasks.types.SystemIncludePath;
  import com.github.maven_nar.cpptasks.types.UndefineArgument;
  
  /**
   * Tests for CompilerDef.
   */
  public final class TestCompilerDef extends TestProcessorDef {
    /**
     * Sets the name attribute.
     *
     * @param compiler
     *          compiler under test
     * @param name
     *          compiler name
     */
    private static void setCompilerName(final CompilerDef compiler, final String name) {
      final CompilerEnum compilerName = new CompilerEnum();
      compilerName.setValue(name);
      compiler.setName(compilerName);
    }
  
    /**
     * Constructor.
     *
     * @param name
     *          test name
     */
    public TestCompilerDef(final String name) {
      super(name);
    }
  
    /**
     * Creates a new processor.
     *
     * @return new processor
     */
    @Override
    protected ProcessorDef create() {
      return new CompilerDef();
    }
  
    /**
     * Gets the command line arguments that precede filenames.
     *
     * This method filters out <i>-m</i> options because they are
     * platform-specific options of the GNU compiler suite.
     *
     * @param processor
     *          processor under test
     * @return command line arguments
     */
    @Override
    protected String[] getPreArguments(final ProcessorDef processor) {
      final String[] result = ((CommandLineCompilerConfiguration) getConfiguration(processor)).getPreArguments();
  
      // filter out -m (i.e. platform-specific) options
      int j = -1;
      for (int i = 0; i < result.length; i++) {
        if (result[i].startsWith("-m")) {
          continue;
        }
        if (i != ++j) {
         result[j] = result[i];
       }
     }
     if (++j == result.length) {
       return result;
     }
     final String[] filtered = new String[j];
     System.arraycopy(result, 0, filtered, 0, j);
     return filtered;
   }
 
   /**
    * Tests that the classname attribute in the base compiler is effective.
    */
   public void testExtendsClassname() {
     final CompilerDef baseCompiler = new CompilerDef();
     baseCompiler.setClassname("com.github.maven_nar.cpptasks.msvc.MsvcCCompiler");
     final CompilerDef extendedCompiler = (CompilerDef) createExtendedProcessorDef(baseCompiler);
     extendedCompiler.setExceptions(true);
     final String[] preArgs = getPreArguments(extendedCompiler);
     assertEquals("/EHsc", preArgs[2]);
   }
 
   /**
    * Tests that compilerarg's contained in the base compiler definition are
    * effective.
    */
   public void testExtendsCompilerArgs() {
     final CompilerDef baseLinker = new CompilerDef();
     final CompilerArgument linkerArg = new CompilerArgument();
     linkerArg.setValue("/base");
     baseLinker.addConfiguredCompilerArg(linkerArg);
     final CompilerDef extendedLinker = (CompilerDef) createExtendedProcessorDef(baseLinker);
     final String[] preArgs = getPreArguments(extendedLinker);
     // FREEHEP, passes extra option
     assertEquals(3, preArgs.length);
     assertEquals("/base", preArgs[0]);
   }
 
   /**
    * Tests that defineset's contained in the base compiler definition are
    * effective.
    */
   public void testExtendsDefineSet() {
     final CompilerDef baseCompiler = new CompilerDef();
     final DefineSet defSet = new DefineSet();
     final DefineArgument define = new DefineArgument();
     define.setName("foo");
     define.setValue("bar");
     defSet.addDefine(define);
     baseCompiler.addConfiguredDefineset(defSet);
     final CompilerDef extendedCompiler = (CompilerDef) createExtendedProcessorDef(baseCompiler);
     final String[] preArgs = getPreArguments(extendedCompiler);
     // BEGINFREEHEP, passes extra option
     assertEquals(3, preArgs.length);
     assertEquals("-Dfoo=bar", preArgs[2]);
     // ENDFREEHEP
   }
 
   /**
    * Tests that the extend attribute of the base compiler definition is
    * effective.
    */
   public void testExtendsExceptions() {
     final CompilerDef baseCompiler = new CompilerDef();
     baseCompiler.setExceptions(true);
     final CompilerDef extendedCompiler = (CompilerDef) createExtendedProcessorDef(baseCompiler);
     setCompilerName(extendedCompiler, "msvc");
     final String[] preArgs = getPreArguments(extendedCompiler);
     assertEquals("/EHsc", preArgs[2]);
   }
 
   /**
    * Tests if a fileset enclosed in the base compiler definition is effective.
    *
    * @throws IOException
    *           if unable to create or delete a temporary file
    */
   public void testExtendsFileSet() throws IOException {
     super.testExtendsFileSet(File.createTempFile("cpptaskstest", ".cpp"));
   }
 
   /**
    * Tests that includepath's contained in the base compiler definition are
    * effective.
    */
   public void testExtendsIncludePath() {
     final CompilerDef baseCompiler = new CompilerDef();
     final CompilerDef extendedCompiler = (CompilerDef) createExtendedProcessorDef(baseCompiler);
     final IncludePath path = baseCompiler.createIncludePath();
     path.setPath("/tmp");
     final String[] preArgs = getPreArguments(extendedCompiler);
     // BEGINFREEHEP, passes extra option
     assertEquals(3, preArgs.length);
     assertEquals("-I", preArgs[2].substring(0, 2));
     // ENDFREEHEP
   }
 
   /**
    * Tests that the multithread attribute of the base compiler definition is
    * effective.
    */
   public void testExtendsMultithreaded() {
     final CompilerDef baseCompiler = new CompilerDef();
     baseCompiler.setMultithreaded(false);
     final CompilerDef extendedCompiler = (CompilerDef) createExtendedProcessorDef(baseCompiler);
     setCompilerName(extendedCompiler, "msvc");
     final CCTask cctask = new CCTask();
     final LinkType linkType = new LinkType();
     final File objDir = new File("dummy");
     cctask.setObjdir(objDir);
     linkType.setStaticRuntime(true);
     final CommandLineCompilerConfiguration config = (CommandLineCompilerConfiguration) extendedCompiler
         .createConfiguration(cctask, linkType, null, null, null);
     final String[] preArgs = config.getPreArguments();
     assertEquals("/ML", preArgs[3]);
   }
 
   /**
    * Tests that the name attribute in the base compiler is effective.
    */
   public void testExtendsName() {
     final CompilerDef baseCompiler = new CompilerDef();
     setCompilerName(baseCompiler, "msvc");
     final CompilerDef extendedCompiler = (CompilerDef) createExtendedProcessorDef(baseCompiler);
     extendedCompiler.setExceptions(true);
     final String[] preArgs = getPreArguments(extendedCompiler);
     assertEquals("/EHsc", preArgs[2]);
   }
 
   /**
    * Tests if the rebuild attribute of the base compiler definition is
    * effective.
    *
    */
   public void testExtendsRebuild() {
     testExtendsRebuild(new CompilerDef());
   }
 
   /**
    * Tests that sysincludepath's contained in the base compiler definition are
    * effective.
    */
   public void testExtendsSysIncludePath() {
     final CompilerDef baseCompiler = new CompilerDef();
     final CompilerDef extendedCompiler = (CompilerDef) createExtendedProcessorDef(baseCompiler);
     final SystemIncludePath path = baseCompiler.createSysIncludePath();
     path.setPath("/tmp");
     final String[] preArgs = getPreArguments(extendedCompiler);
     System.out.println("Class: " + baseCompiler + " and: " + extendedCompiler);
     // BEGINFREEHEP, passes extra option
     assertEquals(3, preArgs.length);
     assertEquals("-isystem", preArgs[2].substring(0, 8));
     // ENDFREEHEP
   }
 
   /**
    * This method tests CompilerDef.getActiveDefines.
    *
    * A CompilerDef is created similar to what would be created for
    *
    * <cc><defineset><define name="DEBUG" if="debug"/> <define name="NDEBUG"
    * unless="debug"/> </defineset> </cc>
    *
    * Then getActiveDefines is called for a project without and with the
    * "debug" property defined. Return value from getActiveDefines should
    * contain one member
    */
   public void testGetActiveDefines() {
     final Project project = new org.apache.tools.ant.Project();
     final CompilerDef def = new CompilerDef();
     def.setProject(project);
     final DefineSet defset = new DefineSet();
     final DefineArgument arg1 = new DefineArgument();
     arg1.setName("DEBUG");
     arg1.setIf("debug");
     defset.addDefine(arg1);
     final DefineArgument arg2 = new DefineArgument();
     arg2.setName("NDEBUG");
     arg2.setUnless("debug");
     defset.addDefine(arg2);
     def.addConfiguredDefineset(defset);
     //
     // Evaluate without "debug" set
     //
     UndefineArgument[] activeArgs = def.getActiveDefines();
     assertEquals(1, activeArgs.length);
     assertEquals("NDEBUG", activeArgs[0].getName());
     //
     // Set the "debug" property
     //
     project.setProperty("debug", "");
     activeArgs = def.getActiveDefines();
     assertEquals(1, activeArgs.length);
     assertEquals("DEBUG", activeArgs[0].getName());
   }
 
   /**
    * This method tests CompilerDef.getActiveIncludePath.
    *
    * A CompilerDef is created similar to what would be created for
    *
    * <cc><includepath location=".." if="debug"/> </cc>
    *
    * and is evaluate for a project without and without "debug" set
    */
   public void testGetActiveIncludePaths() {
     final Project project = new org.apache.tools.ant.Project();
     final CompilerDef def = new CompilerDef();
     def.setProject(project);
     final ConditionalPath path = def.createIncludePath();
     path.setLocation(new File(".."));
     path.setIf("debug");
     //
     // Evaluate without "debug" set
     //
     String[] includePaths = def.getActiveIncludePaths();
     assertEquals(0, includePaths.length);
     //
     // Set the "debug" property
     //
     project.setProperty("debug", "");
     includePaths = def.getActiveIncludePaths();
     assertEquals(1, includePaths.length);
   }
 
   /**
    * Tests that setting classname to the Gcc compiler is effective.
    */
   public void testGetGcc() {
     final CompilerDef compilerDef = (CompilerDef) create();
     compilerDef.setClassname("com.github.maven_nar.cpptasks.gcc.GccCCompiler");
     final Compiler comp = (Compiler) compilerDef.getProcessor();
     assertNotNull(comp);
     assertSame(GccCCompiler.getInstance(), comp);
   }
 
   /**
    * Tests that setting classname to the MSVC compiler is effective.
    */
   public void testGetMSVC() {
     final CompilerDef compilerDef = (CompilerDef) create();
     compilerDef.setClassname("com.github.maven_nar.cpptasks.msvc.MsvcCCompiler");
     final Compiler comp = (Compiler) compilerDef.getProcessor();
     assertNotNull(comp);
     assertSame(MsvcCCompiler.getInstance(), comp);
   }
 
   /**
    * Tests that setting classname to an bogus class name results in a
    * BuildException.
    */
   public void testUnknownClass() {
     final CompilerDef compilerDef = (CompilerDef) create();
     try {
       compilerDef.setClassname("com.github.maven_nar.cpptasks.bogus.BogusCompiler");
     } catch (final BuildException ex) {
       return;
     }
     fail("Exception not thrown");
   }
 
   /**
    * Test that setting classname to a class that doesn't support Compiler
    * throws a BuildException.
    *
    */
   public void testWrongType() {
     final CompilerDef compilerDef = (CompilerDef) create();
     try {
       compilerDef.setClassname("com.github.maven_nar.cpptasks.msvc.MsvcLinker");
     } catch (final BuildException ex) {
       return;
     }
     fail("Exception not thrown");
   }
 }