%TestSuite Collection of TestComponent objects
%   The TestSuite class defines a collection of TestComponent objects.
%
%   TestSuite methods:
%       TestSuite             - Constructor
%       add                   - Add test component to test suite
%       print                 - Display test suite summary to Command Window
%       run                   - Run the test suite
%       keepMatchingTestCase  - Keep only the named test component
%       fromName              - Construct test suite from directory or MATLAB function file name
%       fromTestCaseClassName - Construct test suite from TestCase class name
%       fromPackageName       - Construct test suite from package name
%       fromPwd               - Construct test suite from present directory
%
%   TestSuite properties:
%       TestComponents - Cell array of TestComponent objects
%
%   Examples
%   --------
%   Run all the test cases in the SampleTests1 class.  Display test suite
%   progress and a summary of results in the Command Window.
%
%       TestSuite('SampleTests1').run()
%
%   Construct a test suite from all test components found in the current
%   directory.
%
%       suite = TestSuite.fromPwd();
%
%   Construct a test suite from all test components found in the package
%   'mytool.tests'. (Note that the "+" character at the beginning of the package
%   folder name on disk is not part of the package name.)
%
%       suite = TestSuite.fromPackageName('mytool.tests');
%
%   Run all the test cases in the SampleTests class.  Display no output to the
%   Command Window.  Upon completion, query the number of test failures and test
%   errors.
%
%       logger = TestRunLogger();
%       TestSuite('SampleTests1').run(logger);
%       numFailures = logger.NumFailures
%       numErrors = logger.NumErrors
%
%   See also CommandWindowTestRunDisplay, TestCase, TestComponent, TestRunLogger

%   Steven L. Eddins
%   Copyright 2008-2010 The MathWorks, Inc.

classdef TestSuite < TestComponent
    
    properties (SetAccess = protected)
        TestComponents = {};
    end
    
    methods
        
        function self = TestSuite(name)
            %TestSuite Constructor
            %   suite = TestSuite constructs an empty test suite. suite =
            %   TestSuite(name) constructs a test suite by searching for test
            %   cases defined in an M-file with the specified name.
            
            if nargin >= 1
                self = TestSuite.fromName(name);
            end
        end
        
        function did_pass_out = run(self, monitor)
            %run Execute test cases in test suite
            %   did_pass = suite.run() executes all test cases in the test
            %   suite, returning a logical value indicating whether or not all
            %   test cases passed.
            
            if nargin < 2
                monitor = CommandWindowTestRunDisplay();
            end
            
            monitor.testComponentStarted(self);
            did_pass = true;
            
            self.setUp();
            
            for k = 1:numel(self.TestComponents)
                this_component_passed = self.TestComponents{k}.run(monitor);
                did_pass = did_pass && this_component_passed;
            end
            
            self.tearDown();
            
            monitor.testComponentFinished(self, did_pass);
            
            if nargout > 0
                did_pass_out = did_pass;
            end
        end
        
        function num = numTestCases(self)
            %numTestCases Number of test cases in test suite
            
            num = 0;
            for k = 1:numel(self.TestComponents)
                component_k = self.TestComponents{k};
                num = num + component_k.numTestCases();
            end
        end
        
        function print(self, numLeadingBlanks)
            %print Display test suite summary to Command Window
            %   test_suite.print() displays a summary of the test suite to the
            %   Command Window.
            
            if nargin < 2
                numLeadingBlanks = 0;
            end
            fprintf('%s%s\n', blanks(numLeadingBlanks), self.Name);
            for k = 1:numel(self.TestComponents)
                self.TestComponents{k}.print(numLeadingBlanks + ...
                    self.PrintIndentationSize);
            end
        end
        
        function add(self, component)
            %add Add test component to test suite
            %   test_suite.add(component) adds the TestComponent object to the
            %   test suite.
            
            if iscell(component)
                self.TestComponents((1:numel(component)) + end) = component;
            else
                self.TestComponents{end + 1} = component;
            end
        end
        
        function keepMatchingTestCase(self, name)
            %keepMatchingTestCase Keep only the named test component
            %   test_suite.keepMatchingTestCase(name) keeps only the test
            %   component with a matching name and discards the rest.
            
            idx = [];
            for k = 1:numel(self.TestComponents)
                if strcmp(self.TestComponents{k}.Name, name)
                    idx = k;
                    break;
                end
            end
            if isempty(idx)
                self.TestComponents = {};
            else
                self.TestComponents = self.TestComponents(idx);
            end
        end
        
    end
    
    methods (Static)
        function suite = fromTestCaseClassName(class_name)
            %fromTestCaseClassName Construct test suite from TestCase class name
            %   suite = TestSuite.fromTestCaseClassName(name) constructs a
            %   TestSuite object from the name of a TestCase subclass.
            
            if ~xunit.utils.isTestCaseSubclass(class_name)
                error('xunit:fromTestCaseClassName', ...
                    'Input string "%s" is not the name of a TestCase class.', ...
                    class_name);
            end
            
            suite = TestSuite;
            suite.Name = class_name;
            suite.Location = which(class_name);
            
            methods = getClassMethods(class_name);
            for k = 1:numel(methods)
                if methodIsConstructor(methods{k})
                    continue
                end
                
                method_name = methods{k}.Name;
                if xunit.utils.isTestString(method_name)
                    suite.add(feval(class_name, method_name));
                end
            end
            
        end
        
        function suite = fromName(name)
            %fromName Construct test suite from M-file name
            %   test_suite = TestSuite.fromName(name) constructs a TestSuite
            %   object from an M-file with the given name.  The name can be of a
            %   directory, a TestCase subclass, or an M-file containing a simple
            %   test or containing subfunction-based tests.
            %
            %   Optionally, name can contain a colon (':') followed by filter
            %   string.  The filter string is used to select a particular named
            %   test case.  For example, TestSuite.fromName('MyTests:testA')
            %   constructs a TestSuite object containing only the test case
            %   named 'testA' found in the TestCase subclass MyTests.
            
            if isdir(name)
                suite = TestSuiteInDir(name);
                suite.gatherTestCases();
                return;
            end
            
            [name, filter_string] = strtok(name, ':');
            if ~isempty(filter_string)
                filter_string = filter_string(2:end);
            end
            
            if xunit.utils.isTestCaseSubclass(name)
                suite = TestSuite.fromTestCaseClassName(name);
                
            elseif ~isempty(meta.class.fromName(name))
                % Input is the name of a class that is not a TestCase subclass.
                % Return an empty test suite.
                suite = TestSuite();
                suite.Name = name;
                
            elseif isPackage(name)
                suite = TestSuite.fromPackageName(name);
                
            else
                
                try
                    if nargout(name) == 0
                        suite = TestSuite();
                        suite.Name = name;
                        suite.add(FunctionHandleTestCase(str2func(name), [], []));
                        suite.Location = which(name);
                        
                    else
                        suite = feval(name);
                        if ~isa(suite, 'TestSuite')
                            error('Function did not return a TestSuite object.');
                        end
                    end
                    
                catch
                    % Ordinary function does not appear to contain tests.
                    % Return an empty test suite.
                    suite = TestSuite();
                    suite.Name = name;
                end
            end
            
            if ~isempty(filter_string)
                suite.keepMatchingTestCase(filter_string);
            end
        end
        
        function test_suite = fromPwd()
            %fromPwd Construct test suite from present directory
            %   test_suite = TestSuite.fromPwd() constructs a TestSuite object
            %   from all the test components in the present working directory.
            %   all TestCase subclasses will be found, as well as simple and
            %   subfunction-based M-file tests beginning with the string 'test'
            %   or 'Test'.
            
            test_suite = TestSuite();
            test_suite.Name = pwd;
            test_suite.Location = pwd;
            
            mfiles = dir(fullfile('.', '*.m'));
            for k = 1:numel(mfiles)
                [path, name] = fileparts(mfiles(k).name);
                if xunit.utils.isTestCaseSubclass(name)
                    test_suite.add(TestSuite.fromTestCaseClassName(name));
                elseif xunit.utils.isTestString(name)
                    suite_k = TestSuite.fromName(name);
                    if ~isempty(suite_k.TestComponents)
                        test_suite.add(suite_k);
                    end
                end
            end
        end
        
        function test_suite = fromPackageName(name)
            %fromPackageName Construct test suite from package name
            %   test_suite = TestSuite.fromPackageName(name) constructs a
            %   TestSuite object from all the test components found in the
            %   specified package.

            package_info = meta.package.fromName(name);
            if isempty(package_info)
                error('xunit:fromPackageName:invalidName', ...
                    'Input string "%s" is not the name of a package.', ...
                    name);
            end
            test_suite = TestSuite();
            test_suite.Name = name;
            test_suite.Location = 'Package';
            
            for k = 1:numel(package_info.Packages)
                pkg_name = package_info.Packages{k}.Name;
                pkg_suite = TestSuite.fromPackageName(pkg_name);
                if ~isempty(pkg_suite.TestComponents)
                    test_suite.add(TestSuite.fromPackageName(pkg_name));
                end
            end
            
            class_names = cell(1, numel(package_info.Classes));
            for k = 1:numel(package_info.Classes)
                class_name = package_info.Classes{k}.Name;
                class_names{k} = class_name;
                if xunit.utils.isTestCaseSubclass(class_name)
                    test_suite.add(TestSuite.fromTestCaseClassName(class_name));
                end
            end
            
            for k = 1:numel(package_info.Functions)
                function_name = package_info.Functions{k}.Name;
                if xunit.utils.isTestString(function_name)
                    full_function_name = [package_info.Name '.' package_info.Functions{k}.Name];
                    if ~ismember(full_function_name, class_names)
                        suite_k = TestSuite.fromName(full_function_name);
                        if ~isempty(suite_k.TestComponents)
                            test_suite.add(suite_k);
                        end
                    end
                end
            end
        end
    end
end

function tf = isPackage(name)
tf = ~isempty(meta.package.fromName(name));
end

function methods = getClassMethods(class_name)
class_meta = meta.class.fromName(class_name);
methods = class_meta.Methods;
end

function result = methodIsConstructor(method)
method_name = method.Name;
if ~isempty(method.DefiningClass.ContainingPackage)
    method_name = [method.DefiningClass.ContainingPackage.Name, '.', ...
        method_name];
end
result = strcmp(method_name, method.DefiningClass.Name);
end