CodeSnip Old Code (SVN)

{
 * UTestCompile.pas
 *
 * Class that performs a test compilation of a routine using all supported and
 * installed versions of Delphi and returns details of success or failure.
 *
 * v0.1 of 30 Jan 2005  - Original version.
 * v0.2 of 18 Feb 2005  - Deleted unused TTestCompile destructor.
 * v0.3 of 23 Feb 2005  - Added static, overloaded, Compile method to
 *                        TTestCompile that compiles a specified routine without
 *                        user having to instantiate the class.
 * v0.4 of 05 Apr 2005  - Changed to use TCompilerID to list supported
 *                        compilers.
 *                      - Changed to use revised ICompiler based compiler object
 *                        to perform actual compilation.
 *                      - Changed to call ICompiler object to tidy binary files
 *                        rather than deleting in this object: this allows for
 *                        different file type across compilers.
 * v0.5 of 20 Apr 2005  - Changed to use renamed USourceGen unit and associated
 *                        renamed class and method.
 *                      - Changed to use renamed IntfCompilers unit.
 * v0.6 of 08 Jan 2006  - Altered some method signatures to remove unused
 *                        parameters.
 * v1.0 of 24 May 2006  - Improved and corrected comments.
 *                      - Removed unused unit references.
 * v1.1 of 04 Dec 2006  - Changed to use TTestUnit to generate test unit and
 *                        removed code from this class that formerly did this.
 * v1.2 of 01 Mar 2007  - Added new TTestCompileThread class.
 * v1.3 of 24 Aug 2008  - Added Windows unit to enable inlining in Delphi 2006.
 * v1.4 of 04 Oct 2008  - Made constructor protected and removed Compile
 *                        instance method, leaving only class Compile method.
 *                        static. Modified other methods accordingly.
 *                      - Made private and protected sections strict.
 *                      - Moved TTestCompile class to implementation.
 *                      - Now use ClassName method in all assert statements.
 * v1.5 of 16 Dec 2008  - Iteration of Compilers changed to use for..in loop.
 * v1.6 of 06 Jan 2009  - Changed to use a specified compilers object to perform
 *                        test compilation instead of global Compilers object.
 * v1.7 of 11 Jan 2009  - Moved TTestCompile to interface.
 *                      - TTestCompileThread removed as no longer required.
 *
 *
 * ***** BEGIN LICENSE BLOCK *****
 *
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
 * the specific language governing rights and limitations under the License.
 *
 * The Original Code is UTestCompile.pas
 *
 * The Initial Developer of the Original Code is Peter Johnson
 * (http://www.delphidabbler.com/).
 *
 * Portions created by the Initial Developer are Copyright (C) 2005-2009 Peter
 * Johnson. All Rights Reserved.
 *
 * ***** END LICENSE BLOCK *****
}


unit UTestCompile;


interface


uses
  // Project
  IntfCompilers, UBaseObjects, USnippets;


type

  {
  TTestCompile:
    Class that performs a test compilation of a routine using all supported and
    installed compilers and returns details of success or failure.
  }
  TTestCompile = class(TNoPublicConstructObject)
  strict private
    fRoutine: TRoutine;
      {The routine we are to compile}
    fCompilers: ICompilers;
      {Object used to perform compilation}
    procedure GenerateSourceFile(out FileName: string);
      {Generates a source file for routine under test.
        @param FileName [out] Name of the generated file.
      }
    class function CompileSourceFile(const SrcFile: string;
      const Compiler: ICompiler): TCompileResult;
      {Compiles a source file using a specified compiler.
        @param SrcFile [in] Fully specified name of the source file.
        @param Compiler [in] Compiler to be used.
        @return Result of the compilation.
      }
    function DoCompile: TCompileResults;
      {Compiles routine under test with all installed and supported compiler
      versions.
        @return Compilation results for each supported compiler (crQuery is
          returned for each supported compiler that is not installed).
      }
  strict protected
    constructor InternalCreate(const ACompilers: ICompilers;
      const ARoutine: TRoutine);
      {Class constructor. Sets up object that can test compile a routine.
        @param ACompilers [in] Compilers object used to perform compilation.
        @param ARoutine [in] Routine to be test compiled.
      }
  public
    class function Compile(const ACompilers: ICompilers;
      const ARoutine: TRoutine): TCompileResults;
      {Compiles a specified routine with all installed and supported compilers.
        @param ACompilers [in] Compilers object used to perform compilation.
        @param ARoutine [in] Routine to be compiled.
        @return Compilation results for each supported compiler (crQuery is
          returned for each supported compiler that is not installed).
      }
  end;


implementation


uses
  // Delphi
  SysUtils, Windows {for inlining},
  // Project
  UTestUnit;


{ TTestCompile }

class function TTestCompile.Compile(const ACompilers: ICompilers;
  const ARoutine: TRoutine): TCompileResults;
  {Compiles a specified routine with all installed and supported compilers.
    @param ACompilers [in] Compilers object used to perform compilation.
    @param ARoutine [in] Routine to be compiled.
    @return Compilation results for each supported compiler (crQuery is returned
      for each supported compiler that is not installed).
  }
begin
  with InternalCreate(ACompilers, ARoutine) do
    try
      Result := DoCompile;
    finally
      Free;
    end;
end;

class function TTestCompile.CompileSourceFile(const SrcFile: string;
  const Compiler: ICompiler): TCompileResult;
  {Compiles a source file using a specified compiler.
    @param SrcFile [in] Fully specified name of the source file.
    @param Compiler [in] Compiler to be used.
    @return Result of the compilation.
  }
var
  Dir: string;  // Directory containing source file and used for output
begin
  Dir := ExtractFileDir(SrcFile);
  Result := Compiler.Compile(Dir, ExtractFileName(SrcFile));
  Compiler.DeleteObjFiles(Dir, ExtractFileName(SrcFile));
end;

function TTestCompile.DoCompile: TCompileResults;
  {Compiles routine under test with all installed and supported compiler
  versions.
    @return Compilation results for each supported compiler (crQuery is returned
      for each supported compiler that is not installed).
  }
var
  Compiler: ICompiler;  // references each supported compiler
  SrcFileName: string;  // name of test unit source file
begin
  GenerateSourceFile(SrcFileName);
  try
    for Compiler in fCompilers do
      if Compiler.IsAvailable then
        Result[Compiler.GetID] := CompileSourceFile(SrcFileName, Compiler)
      else
        Result[Compiler.GetID] := crQuery;
  finally
    SysUtils.DeleteFile(SrcFileName);
  end;
end;

procedure TTestCompile.GenerateSourceFile(out FileName: string);
  {Generates a source file for routine under test.
    @param FileName [out] Name of the generated file.
  }
begin
  with TTestUnit.Create(fRoutine) do
    try
      SaveUnit(FileName);
    finally
      Free;
    end;
end;

constructor TTestCompile.InternalCreate(const ACompilers: ICompilers;
  const ARoutine: TRoutine);
  {Class constructor. Sets up object that can test compile a routine.
    @param ACompilers [in] Compilers object used to perform compilation.
    @param ARoutine [in] Routine to be test compiled.
  }
begin
  Assert(Assigned(ARoutine),                               // ** do not localise
    ClassName + '.InternalCreate: ARoutine is nil');
  Assert(Assigned(ACompilers),                             // ** do not localise
    ClassName + '.InternalCreate: ACompilers is nil');
  inherited InternalCreate;
  fRoutine := ARoutine;
  fCompilers := ACompilers;
end;

end.