--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/buildxml.rb	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,220 @@
+#!/usr/bin/ruby
+
+require 'ostruct'
+require 'unittest'
+require 'rexml/document'
+include REXML
+
+options = OpenStruct.new
+options.outfile = ""
+options.infile = ""
+options.version = "unknown"
+
+if ARGV[1]==nil then
+  puts "Usage: buildxml.rb <inputfile> <outputfile>"
+  exit
+else
+  options.infile = ARGV[0]
+  options.outfile = ARGV[1]
+end
+
+class UnitTestProcessor  
+  attr_accessor :ut
+  
+  def initialize
+    @ut = UnitTest.new
+    @results = []
+  end
+  
+  def result=(newResult)
+    testvalues = newResult.split(",")
+    @ut.path = getPath(testvalues)
+    @ut.title = getTitle(testvalues)
+    @ut.code = getCode(testvalues)
+    result = Result.new
+    result.syntax = testvalues[1]
+    result.algorithm = testvalues[2]
+    result.date = Date.new(testvalues[4].to_i)
+    result.number = testvalues[3].to_i
+    @ut.results << result
+  end
+
+  # generates the path out of the test name
+  def getPath(testvalues)
+    parts = testvalues[0].split("_")
+    folder = parts[1]
+    parts.pop
+    filename = parts.join("_") + ".m"
+    "utps/" + folder + "/" + filename
+  end
+  
+  # generates the title out of the test name
+  def getTitle(testvalues)
+    parts = testvalues[0].split("_")
+    parts.pop
+    parts.shift
+    #parts[0].upcase!
+    parts.join(" ")
+  end
+  
+  # generates the title out of the test name
+  def getCode(testvalues)
+    parts = testvalues[0].split("_")
+    parts.pop
+    parts.join("_")
+  end
+    
+  def parseFile
+    begin
+      if !File.exists? @ut.path then
+        return
+      end
+      inFile = File.new(@ut.path)
+      currentTest = SubTest.new
+      while line = inFile.readline.chomp
+        # TODO: strip HTML-Tags
+        # remove trailing spaces
+        line.rstrip!
+        
+        if line.match /[%]+[ ]+UTP_[0-9]+/ then
+          currentTest = SubTest.new
+          parts = line.split("_")
+          currentTest.number = parts[1].to_i
+        end
+        
+        if line.match(/[%]+[ ]+END[ ]+UTP_[0-9]+/) and currentTest.number > 0 then
+          @ut.tests << currentTest
+        end
+        
+        if line.match "</MethodDescription>" then writeTo = "none" end
+        if line.match "</SyntaxDescription>" then writeTo = "none" end
+        if line.match "</TestDescription>" then writeTo = "none" end
+        if line.match "</AlgoDescription>" then writeTo = "none" end
+        if line.match "</SyntaxCode>" then writeTo = "none" end
+        if line.match "</AlgoCode>" then writeTo = "none" end
+          
+          
+        
+        case writeTo
+          when "none" then
+            a = 1
+          when "algoCode" then
+            currentTest.algoCode += line + "\n"
+          when "algoDescription" then
+            currentTest.algoDescription += removeComment line
+          when "syntaxCode" then
+            currentTest.syntaxCode += line + "\n"
+          when "syntaxDescription" then
+            currentTest.syntaxDescription += removeComment line
+          when "methodDescription" then
+            @ut.methodDescription += removeComment line
+          when "testDescription" then
+            currentTest.testDescription += removeComment line
+        end
+        
+        if line.match "<MethodDescription>" then writeTo = "methodDescription" end
+        if line.match "<SyntaxDescription>" then writeTo = "syntaxDescription" end
+        if line.match "<TestDescription>" then writeTo = "testDescription" end
+        if line.match "<AlgoDescription>" then writeTo = "algoDescription" end
+        if line.match "<SyntaxCode>" then writeTo = "syntaxCode" end
+        if line.match "<AlgoCode>" then writeTo = "algoCode" end
+        
+      end
+    rescue EOFError
+      inFile.close
+    end
+  end
+  
+  # The analysis of a single line of the .m file
+  def removeComment(line)
+    line.strip!
+    while line.match /^%/
+      # not elegant, but works in every realistic case (cut off at 100000 chars)
+      line = line[1,100000]
+      line.strip!
+    end
+    if line.length>0 then
+      line = line + "<br />"
+    end
+    line
+  end
+  
+  # Merge Results and Test for easier access
+  def mergeTestsAndResults
+    @ut.tests.each do |t|
+      @ut.results.each do |r|
+        if t.number == r.number then
+          t.date = r.date
+          t.syntaxResult = r.syntax.to_i
+          t.algoResult = r.algorithm.to_i
+          if t.syntaxResult==0 or t.algoResult==0 then
+            @ut.tainted = true
+          end
+        end
+      end
+    end
+  end
+end
+
+infile = File.open(options.infile, 'r');
+outfile = File.open(options.outfile, 'w');
+
+tests = []
+
+begin
+  while line = infile.readline.chomp
+    testvalues = line.split(",")
+    parts = testvalues[0].split("_")
+    parts.pop
+    tests << parts.join("_")
+  end
+rescue EOFError
+  infile.close
+end
+
+tests = tests.uniq
+
+# For testing: tests fet only for the first test
+#tests = []
+#tests << "utp_ao_join_fsdata"
+utps = []
+puts "Collecting data ..."
+tests.each do |t|
+  inFile = File.open(options.infile, 'r')
+  utp = UnitTestProcessor.new
+  begin
+    while line = inFile.readline.chomp
+      if line.match t then
+        utp.result = line
+      end
+    end
+  rescue EOFError
+    inFile.close
+  end
+  utps << utp
+end
+
+unittests = []
+
+i=1
+
+utps.each do |u|
+  puts "Parsing file " + i.to_s + " of " + utps.length.to_s + " (" + u.ut.path + ") ..."
+  i += 1
+  u.parseFile
+  u.mergeTestsAndResults
+  unittests << u.ut
+end
+
+#if(options.outfile HERE MATCHES DAT) then
+  Marshal.dump(unittests, outfile)
+#elseif(optione.outfile. HERE MATCHES XML then
+#  doc = Document.new()
+#  root = Element.new("Report")
+#  root.add_attribute 'date', Time.now.to_s
+#  root.add_attribute 'version', options.version
+#  unittests.each do |u|
+#    testEl = Element.new("
+#  end
+#end
+outfile.close

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/display_utp_results.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,12 @@
+% DISPLAY_UTP_RESULTS displays the results structure to the terminal.
+%
+% M Hewitson 07-08-08
+%
+% $Id: display_utp_results.m,v 1.7 2010/07/14 10:18:40 hewitson Exp $
+%
+
+function display_utp_results(results)
+  
+  disp(print_utp_results(results));
+
+end

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/document_utp_results.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,145 @@
+% Given a set of results from utp_run, this function attaches additional
+% documentation for each unit test.
+function newResults = document_utp_results(results)
+  
+  
+  for kk=1:numel(results)
+    fprintf(1, '+ %d documenting %s/%s/%s\n', kk, results(kk).class, results(kk).method, results(kk).num);
+    newResults(kk) = readUTP(results(kk));
+  end
+  
+end
+
+
+function result = readUTP(result)
+  
+  filename = result.file;
+  utpFcn   = result.utp;
+  
+  
+  % parse the utp fcn
+  parts = regexp(utpFcn, filesep, 'split');
+  utp = parts{end};
+  
+  if strcmp(utp, 'xx')
+    % the utp failed to run
+    result.doc.desc = '';
+    result.doc.syntax = '';
+    result.doc.syntaxCode = '';
+    result.doc.algo = '';
+    result.doc.algoCode = '';
+    return;
+  end
+  
+  
+  fd = fopen(filename);
+  if fd < 0
+    warning('Failed to open %s', filename);
+    
+  end
+  
+  fulltxt = {};
+  while ~feof(fd)
+    fulltxt = [fulltxt {fgetl(fd)}];
+  end
+  
+  fclose(fd);
+  
+  % parse the txt for this test only
+  
+  % 1) find the utp_XX
+  % 2) backtrack to find <TestDescription>
+  % 3) read forward to get the end of the fcn (count even closing end's)
+  
+  res = regexp(fulltxt, ['result\s*=\s*' utp]);
+  fcnLine = find(~cellfun('isempty', res));
+  
+  % backtrack to look for the test description start
+  line = findLine(fulltxt, '<TestDescription>', fcnLine, true);
+  
+  % parse out the test description
+  result.doc.desc = parseSection(fulltxt(line:end), utp, '<TestDescription>', '</TestDescription>', result.class, result.method, true, true);
+    
+  % parse out the syntax test
+  result.doc.syntax = parseSection(fulltxt(line:end), utp, '<SyntaxDescription>', '</SyntaxDescription>', result.class, result.method, true, true);
+  
+  % parse out syntax code
+  result.doc.syntaxCode = parseSection(fulltxt(line:end), utp, '<SyntaxCode>', '</SyntaxCode>', result.class, result.method, false, false);
+  
+  % parse out the algorithm test
+  result.doc.algo = parseSection(fulltxt(line:end), utp, '<AlgoDescription>', '</AlgoDescription>', result.class, result.method, true, true);
+  
+  % parse out algorithm code
+  result.doc.algoCode = parseSection(fulltxt(line:end), utp, '<AlgoCode>', '</AlgoCode>', result.class, result.method, false, false);
+  
+  
+  
+end
+
+function line = findLine(lines, tag, startLine, backwards)
+  
+  
+  % backtrack to look for the test description start
+  line = startLine;
+  if backwards
+    while line > 0      
+      try
+      if strfind(lines{line}, tag)
+        break;
+      end
+      catch
+        lines
+        line
+        tag
+      end
+      line = line - 1;
+    end
+  else
+    while line <= numel(lines)      
+      if strfind(lines{line}, tag)
+        break;
+      end      
+      line = line + 1;
+    end
+  end
+  
+end
+
+function desc = parseSection(lines, utp, startTag, endTag, class, method, stripComments, trimLines)
+  
+  % go forward capturing the description until we hit end of the
+  % description
+  line = 1;
+  desc = '';
+  foundStart = false;
+  while line < numel(lines)
+    if strfind(lines{line}, startTag)
+      foundStart = true;
+    end
+    if foundStart
+      lineTxt = lines{line};
+      if stripComments
+        lineTxt = strrep(lineTxt, '%', '');
+      end
+      lineTxt = regexprep(lineTxt, ['%*\s*' startTag], '');
+      lineTxt = regexprep(lineTxt, ['%*\s*' endTag], '');
+      lineTxt = strrep(lineTxt, '<METHOD>', ['[' class '/' method ']']);
+      if trimLines
+        lineTxt = strtrim(lineTxt);
+      end
+      desc = [desc sprintf('%s\n', lineTxt)];
+    end
+    if strfind(lines{line}, endTag)
+      break;
+    end
+    line = line + 1;
+  end
+  
+  desc = strtrim(desc);
+  
+  
+end
+
+
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generate_report.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,256 @@
+% GERERATE_REPORT reads all unit test and generates a report.
+
+% TODO
+% 
+%   + Format UTP table by hand - not using \utp
+%   + move code block to tables in appendix with same numbering as UTP tables
+%   + add pdf link in UTP table to code block
+%   + keep code indentation from m-file
+%   + wrap strings using utils.prog.wrapstring (or similar) - add ... 
+% 
+
+function report = generate_report()
+
+  setappdata(0, 'ltpda_verbose_level', -1);
+
+  pdfFilename = 'report/report.pdf';
+  texFilename = 'report/ltpda_report_template.html';
+  repFilename = 'report/report.html';
+
+  load resultsave.mat results
+  % results = utp_run('utp_ao_log10');
+  disp(results(1).a);
+  disp(results(1).s);
+  disp(results(1).fcn);
+  disp(results(1).num);
+  disp(results(1).date);
+
+  inFile = fopen(texFilename, 'r');
+
+  methodDescription = '';
+  testDescription = '';
+  syntaxDescription = '';
+  algoDescription = '';
+  syntaxCode = '';
+  algoCode = '';
+
+  writeDirectly = true;
+  outputTex = '';
+
+  % Get the rest:
+  while ~feof(inFile)
+    line = fgetl(inFile);
+
+    if strfind(line, '<!-- Report /-->')
+      writeDirectly = false;
+      preTests = outputTex;
+      outputTex = '';
+    end
+
+    if strfind(line, '<!-- EndReport /-->')
+      writeDirectly = true;
+    end
+
+    if strfind(line, '<!-- MethodDescription /-->')
+      methodDescription = '';
+      while isempty(strfind(line, '<!-- EndMethodDescription /-->'))
+        methodDescription = sprintf('%s%s\n', methodDescription, line);
+        line = fgetl(inFile);
+      end
+      methodDescription = sprintf('%s%s\n', methodDescription, line);
+    end
+
+    if strfind(line, '<!-- TestDescription /-->')
+      testDescription = '';
+      while isempty(strfind(line, '<!-- EndTestDescription /-->'))
+        testDescription = sprintf('%s%s\n', testDescription, line);
+        line = fgetl(inFile);
+      end
+      testDescription = sprintf('%s%s\n', testDescription, line);
+    end
+
+    if strfind(line, '<!-- SyntaxDescription /-->')
+      syntaxDescription = '';
+      while isempty(strfind(line, '<!-- EndSyntaxDescription /-->'))
+        syntaxDescription = sprintf('%s%s\n', syntaxDescription, line);
+        line = fgetl(inFile);
+      end
+      syntaxDescription = sprintf('%s%s\n', syntaxDescription, line);
+    end
+
+    if strfind(line, '<!-- AlgoDescription /-->')
+      algoDescription = '';
+      while isempty(strfind(line, '<!-- EndAlgoDescription /-->'))
+        algoDescription = sprintf('%s%s\n', algoDescription, line);
+        line = fgetl(inFile);
+      end
+      algoDescription = sprintf('%s%s\n', algoDescription, line);
+    end
+
+    if strfind(line, '<!-- SyntaxCode /-->')
+      syntaxCode = '';
+      while isempty(strfind(line, '<!-- EndSyntaxCode /-->'))
+        syntaxCode = sprintf('%s%s\n', syntaxCode, line);
+        line = fgetl(inFile);
+      end
+      syntaxCode = sprintf('%s%s\n', syntaxCode, line);
+    end
+
+    if strfind(line, '<!-- AlgoCode /-->')
+      algoCode = '';
+      while isempty(strfind(line, '<!-- EndAlgoCode /-->'))
+        algoCode = sprintf('%s%s\n', algoCode, line);
+        line = fgetl(inFile);
+      end
+      algoCode = sprintf('%s%s\n', algoCode, line);
+    end
+
+    if writeDirectly
+      outputTex = sprintf('%s%s\n', outputTex, line);
+    end
+  end
+  postTests = outputTex;
+
+  fclose(inFile);
+
+  % All vars are ready, now read test files:
+
+  outFile = fopen(repFilename, 'wt');
+  filenames = {};
+  filenames{end+1} = 's';
+  for i=1:length(results)
+    positions = strfind(results(i).fcn, '_');
+    lastUnderscore = positions(length(positions)) -1;
+    if ~strcmp(filenames{end}, sscanf(results(i).fcn, '%c', lastUnderscore))
+      filenames{end+1} = sscanf(results(i).fcn, '%c', lastUnderscore);
+    end
+  end
+
+  % Print the intro
+  fprintf(outFile, '%s', preTests);
+  temp = '';
+
+  for i=2:length(filenames)
+    filename = ['utps/ao/' filenames{i} '.m'];
+    if exist(filename, 'file')
+      utpRead = fopen(filename);
+
+      headerNumber = 1;
+
+      % Get header:
+      if ~feof(utpRead), header = fgetl(utpRead); end
+      header = remComment(header);
+      header = escTex(header);
+
+      % Get rest:
+      while ~feof(utpRead)
+        line = fgetl(utpRead);
+        line = strtrim(line);
+
+        % if strfind(line, 'function result')
+
+        if strfind(line, '<MethodDescription>')
+          line = fgetl(utpRead);
+          utpMethodDescription = '';
+          while isempty(strfind(line, '</MethodDescription>'))
+            utpMethodDescription = sprintf('%s%s\n', utpMethodDescription, line);
+            line = remComment(fgetl(utpRead));
+          end
+          temp = strrep(methodDescription, '%%%CONTENT%%%', utpMethodDescription);
+          temp = strrep(temp, '%%%HEADER%%%', strrep(filenames{i}, '_', ' '));
+          fprintf(outFile, '%s', temp);
+        end
+
+        if strfind(line, '<TestDescription>')
+          line = fgetl(utpRead);
+          utpTestDescription = '';
+          while isempty(strfind(line, '</TestDescription>'))
+            utpTestDescription = sprintf('%s%s\n', utpTestDescription, line);
+            line = remComment(fgetl(utpRead));
+          end
+          temp = strrep(testDescription, '%%%CONTENT%%%', utpTestDescription);
+          temp = strrep(temp, '%%%HEADER%%%', sprintf('%s %2g', strrep(filenames{i}, '_', ' '), headerNumber));
+          fprintf(outFile, '%s', temp);
+        end
+
+        if strfind(line, '<SyntaxDescription>')
+          line = remComment(fgetl(utpRead));
+          utpSyntaxDescription = '';
+          while isempty(strfind(line, '</SyntaxDescription>'))
+            if ~strcmp(strtrim(line), '')
+              utpSyntaxDescription = sprintf('%s%s <br />\n', utpSyntaxDescription, line);
+            end
+            line = remComment(fgetl(utpRead));
+          end
+          fprintf(outFile, '%s', strrep(syntaxDescription, '%%%CONTENT%%%', utpSyntaxDescription));
+        end
+
+        if strfind(line, '<AlgoDescription>')
+          line = remComment(fgetl(utpRead));
+          utpAlgoDescription = '';
+          while isempty(strfind(line, '</AlgoDescription>'))
+            if ~strcmp(strtrim(line), '')
+              utpAlgoDescription = sprintf('%s%s <br />\n', utpAlgoDescription, line);
+            end
+            line = remComment(fgetl(utpRead));
+          end
+          fprintf(outFile, '%s', strrep(algoDescription, '%%%CONTENT%%%', utpAlgoDescription));
+        end
+
+        if strfind(line, '<SyntaxCode>')
+          line = escComment(fgetl(utpRead));
+          % Get number of spaces before string
+          
+          utpSyntaxCode = '';
+          while isempty(strfind(line, '</SyntaxCode>'))
+            utpSyntaxCode = sprintf('%s%s\n', utpSyntaxCode, line);
+            line = escComment(fgetl(utpRead));
+          end
+          fprintf(outFile, '%s', strrep(syntaxCode, '%%%CONTENT%%%', utpSyntaxCode));
+        end
+
+        if strfind(line, '<AlgoCode>')
+          line = escComment(fgetl(utpRead));
+          utpAlgoCode = '';
+          while isempty(strfind(line, '</AlgoCode>'))
+            utpAlgoCode = sprintf('%s%s\n', utpAlgoCode, line);
+            line = escComment(fgetl(utpRead));
+          end
+          fprintf(outFile, '%s', strrep(algoCode, '%%%CONTENT%%%', utpAlgoCode));
+          headerNumber = headerNumber + 1;
+        end
+
+      end
+      fclose(utpRead);
+    end
+
+  end
+
+  % Print the outro
+  fprintf(outFile, '%s', postTests);
+
+  fclose(outFile);
+
+  report = '';
+
+end
+
+
+function newString = remComment(string)
+  pos = strfind(string, '%');
+  newString = strtrim(string(pos+1:length(string)));
+end
+
+function newString = escComment(string)
+  string = strrep(string, '%', '\%');
+  % string = strtrim(string);
+  newString = sprintf('%s<br />', string);
+end
+
+function newString = escTex(string)
+  string = strrep(string, '\', '\\');
+  string = strrep(string, '%', '\%');
+  string = strrep(string, '_', '\_');
+  string = strrep(string, '^', '\^');
+  newString = string;
+end

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/check_aop_data_object.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,34 @@
+%
+% DESCRIPTION: Generic check for a arithmetic operator unit test which
+%              checks the datatype for a single inputs.
+%
+% CALL:        atest = check_aop_data_object(fcn, in1, in2, out);
+%
+% VERSION:     $Id: check_aop_data_object.m,v 1.2 2010/09/23 18:17:54 ingo Exp $
+%
+
+function atest = check_aop_data_object(fcn, in1, in2, out)
+  d1 = in1.data;
+  d2 = in2.data;
+  
+  if any(strcmpi(func2str(fcn), {'or', 'and', 'xor'}))
+    atest = isa(out.data, 'cdata');
+  else
+    if isa(d1, 'data2D') && isa(d2, 'data2D')
+      if numel(d1.y) > 1
+        dout = d1;
+      elseif numel(d2.y) > 1
+        dout = d2;
+      else
+        dout = d1;
+      end
+    elseif isa(d1, 'data2D') && isa(d2, 'cdata')
+      dout = d1;
+    elseif isa(d1, 'cdata') && isa(d2, 'data2D')
+      dout = d2;
+    else
+      dout = d1;
+    end
+    atest = isa(out.data, class(dout));
+  end
+end

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/check_aop_errors.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,40 @@
+%
+% DESCRIPTION: Generic check for a arithmetic operator unit test which
+%              checks the y-errors for a single inputs.
+%
+% CALL:        atest = check_aop_errors(fcn, in1, in2, out);
+%
+% VERSION:     $Id: check_aop_errors.m,v 1.2 2010/09/21 16:50:14 ingo Exp $
+%
+
+function atest = check_aop_errors(fcn, in1, in2, out)
+  if ~isempty(in1.dy) || ~isempty(in2.dy)
+    
+    din1 = in1.dy;
+    din2 = in2.dy;
+    
+    if isempty(din1)
+      din1 = zeros(size(in1.y));
+    end
+    if isempty(din2)
+      din2 = zeros(size(in2.y));
+    end
+    
+    switch func2str(fcn)
+      case {'plus', 'minus'}
+        dy = sqrt(din1.^2 + din2.^2);
+      case {'times', 'mtimes'}
+        dy = sqrt( (din1./in1.y).^2 + (din2./in2.y).^2 ) .* abs(in1.y.*in2.y);
+      case {'rdivide', 'mrdivide'}
+        dy = sqrt( (din1./in1.y).^2 + (din2./in2.y).^2 ) .* abs(in1.y./in2.y);
+      otherwise
+        dy = [];
+    end
+    
+  else
+    dy = [];
+  end
+  
+  atest = isequal(out.dy, dy);
+  
+end

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/check_aop_history.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,43 @@
+%
+% DESCRIPTION: Generic check for a arithmetic operator unit test which
+%              checks the history for a single inputs.
+%
+% CALL:        atest = check_aop_history(fcn, in1, in2, out);
+%
+% VERSION:     $Id: check_aop_history.m,v 1.4 2010/09/24 16:18:16 ingo Exp $
+%
+
+function atest = check_aop_history(fcn, in1, in2, out)
+  
+  atest = true;
+  % Check the last history step
+  for ii = 1:numel(out)
+    if ~strcmp(out(ii).hist.methodInfo.mname, func2str(fcn)), atest = false; end
+  end
+  
+  doCheck = round(rand(1,1)*10);
+  doCheck = 1;
+  
+  % Check the rebuild only in 10 percent of the unit test. I do this to
+  % speedup the tests.
+  if doCheck == 1
+    try
+      ple = plist('Exceptions', {'created', 'proctime', 'UUID', 'param/desc', 'name', 'methodInvars', 'version'});
+      
+      % Rebuild the output object
+      mout = rebuild(copy(out,1));
+      
+      % The rebuilt object must be the same as 'out'
+      for ii=1:numel(mout)
+        if ~eq(mout(ii), out(ii), ple), atest = false; end
+        if atest == 0
+          break;
+        end
+      end
+      
+    catch
+      atest = false;
+    end
+  end
+  
+end

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/check_aop_units.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,28 @@
+%
+% DESCRIPTION: Generic check for a arithmetic operator unit test which
+%              checks the y-units for a single inputs.
+%
+% CALL:        atest = check_aop_units(fcn, in1, in2, out);
+%
+% VERSION:     $Id: check_aop_units.m,v 1.3 2010/09/23 18:19:21 ingo Exp $
+%
+
+function atest = check_aop_units(fcn, in1, in2, out)
+  if utils.helper.ismember(func2str(fcn), {'plus', 'minus'})
+    % return the first non-empty
+    if ~isempty(in1.data.yunits.strs)
+      uo = in1.data.yunits;
+    else
+      uo = in2.data.yunits;
+    end
+  elseif utils.helper.ismember(func2str(fcn), {'or', 'and', 'xor'})
+    uo = unit();
+  else
+    % For other operators we need to apply the operator
+    uo = fcn(in1.data.yunits, in2.data.yunits);
+  end
+  
+  atest = eq(uo, out.yunits);
+  
+end
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/check_axis_sets.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,51 @@
+function atest = check_axis_sets(io)
+  atest = true;
+  % SET 'None'
+  if ~isempty(io(1).sets), atest = false; end
+  if ~isempty(io(1).plists), atest = false; end
+  % Check all Sets
+  if ~any(strcmpi(io(2).sets, '1D')), atest = false; end
+  if ~any(strcmpi(io(2).sets, '2D')), atest = false; end
+  if ~any(strcmpi(io(2).sets, '3D')), atest = false; end
+  if numel(io(2).plists) ~= numel(io(2).sets), atest = false; end
+  % SET '1D'
+  % Check key
+  if ~io(3).plists.isparam('axis'), atest = false; end
+  if ~io(3).plists.isparam('dim'), atest = false; end
+  if ~io(3).plists.isparam('option'), atest = false; end
+  % Check default value
+  if ~isequal(io(3).plists.find('axis'), 'y'), atest = false; end
+  if ~isEmptyDouble(io(3).plists.find('dim')), atest = false; end
+  if ~isEmptyChar(io(3).plists.find('option')), atest = false; end
+  % Check options
+  if ~isequal(io(3).plists.getOptionsForParam('axis'),   {'y'}), atest = false; end
+  if ~isequal(io(3).plists.getOptionsForParam('dim'),    {[]}), atest = false; end
+  if ~isequal(io(3).plists.getOptionsForParam('option'), {''}), atest = false; end
+  % SET '2D'
+  % Check key
+  if ~io(4).plists.isparam('axis'), atest = false; end
+  if ~io(4).plists.isparam('dim'), atest = false; end
+  if ~io(4).plists.isparam('option'), atest = false; end
+  % Check default value
+  if ~isequal(io(4).plists.find('axis'), 'y'), atest = false; end
+  if ~isEmptyDouble(io(4).plists.find('dim')), atest = false; end
+  if ~isEmptyChar(io(4).plists.find('option')), atest = false; end
+  % Check options
+  if ~isequal(io(4).plists.getOptionsForParam('axis'),   {'x', 'y', 'xy'}), atest = false; end
+  if ~isequal(io(4).plists.getOptionsForParam('dim'),    {[]}), atest = false; end
+  if ~isequal(io(4).plists.getOptionsForParam('option'), {''}), atest = false; end
+  % SET '3D'
+  % Check key
+  if ~io(5).plists.isparam('axis'), atest = false; end
+  if ~io(5).plists.isparam('dim'), atest = false; end
+  if ~io(5).plists.isparam('option'), atest = false; end
+  % Check default value
+  if ~isequal(io(5).plists.find('axis'), 'z'), atest = false; end
+  if ~isEmptyDouble(io(5).plists.find('dim')), atest = false; end
+  if ~isEmptyChar(io(5).plists.find('option')), atest = false; end
+  % Check options
+  if ~isequal(io(5).plists.getOptionsForParam('axis'),   {'x', 'y', 'z', 'xyz'}), atest = false; end
+  if ~isequal(io(5).plists.getOptionsForParam('dim'),    {[]}), atest = false; end
+  if ~isequal(io(5).plists.getOptionsForParam('option'), {''}), atest = false; end
+  
+end

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_02.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,76 @@
+% <TestDescription>
+%
+% Tests that the <METHOD> method works with a vector of objects as input.
+%
+% </TestDescription>
+% 
+% $Id: utp_02.m,v 1.3 2010/07/27 07:13:59 hewitson Exp $
+%
+
+function result = utp_02(method, vec, algo, pli, ple3)
+  
+  % <SyntaxDescription>
+  %
+  % Test that the <METHOD> method works for a vector of objects as input.
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    if isempty(pli)
+      out = feval(method, vec);
+    else
+      out = feval(method, vec, pli);
+    end
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the number of elements in 'out' is the same as in 'vec'
+  % 2) Check that each output object contains the correct data.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check we have the correct number of outputs
+    if ~isequal(size(out), size(vec)), atest = false; end
+    % Check each output against the correct value
+    for kk=1:numel(out)
+      
+      % extra tests for constructors
+      if utils.helper.ismember(method, utils.helper.ltpda_userclasses)
+        
+        % Check that the output is the same except the history
+        if ~eq(vec(kk), out(kk), ple3), atest = false; end
+        % Check the history
+        if ~eq(vec(kk).hist, out(kk).hist.inhists), atest = false; end
+        % Change the output to make sure that it is a 'real' copy
+        out(kk).setDescription('my desc');
+        if eq(vec(kk), out(kk), ple3), atest = false; end
+        
+      else
+        atest = algo(vec(kk), out(kk), pli);
+        if ~atest
+          break;
+        end
+        
+      end
+    end
+    
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_02
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_03.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,70 @@
+% <TestDescription>
+%
+% Tests that the <METHOD> method works with a matrix of objects as input.
+%
+% </TestDescription>
+function result = utp_03(method, mat, algo, pli, ple3)
+  
+  % <SyntaxDescription>
+  %
+  % Test that the <METHOD> method works for a matrix of objects as input.
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    if isempty(pli)
+      out = feval(method, mat);
+    else
+      out = feval(method, mat, pli);
+    end
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the number of elements in 'out' is the same as in 'mat'
+  % 2) Check that each output object contains the correct data.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check we have the correct number of outputs
+    if ~isequal(size(out), size(mat)), atest = false; end
+    % Check each output against the correct value
+    for kk=1:numel(out)
+      
+      % extra tests for constructors
+      if utils.helper.ismember(method, utils.helper.ltpda_userclasses)
+        
+        % Check that the output is the same except the history
+        if ~eq(mat(kk), out(kk), ple3), atest = false; end
+        % Check the history
+        if ~eq(mat(kk).hist, out(kk).hist.inhists), atest = false; end
+        % Change the output to make sure that it is a 'real' copy
+        out(kk).setDescription('my desc');
+        if eq(mat(kk), out(kk), ple3), atest = false; end
+        
+      else
+        atest = algo(mat(kk), out(kk), pli);
+        if ~atest
+          break;
+        end        
+      end
+    end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_02
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_04.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,71 @@
+% <TestDescription>
+%
+% Tests that the <METHOD> method works with a list of objects as input.
+%
+% </TestDescription>
+function result = utp_04(method, obj1, obj2, obj3, algo, pli, ple3)
+  
+  % <SyntaxDescription>
+  %
+  % Test that the <METHOD> method works for a list of objects as input.
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    if isempty(pli)
+      out = feval(method, obj1, obj2, obj3);
+    else
+      out = feval(method, obj1, obj2, obj3, pli);
+    end
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the number of elements in 'out' is the same as in 'mat'
+  % 2) Check that each output object contains the correct data.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    obj_in = [obj1 obj2 obj3];
+    % <AlgoCode>
+    % Check we have the correct number of outputs
+    if ~isequal(size(out), size(obj_in)), atest = false; end
+    % Check each output against the correct value
+    for kk=1:numel(obj_in)
+      
+      % extra tests for constructors
+      if utils.helper.ismember(method, utils.helper.ltpda_userclasses)
+        
+        % Check that the output is the same except the history
+        if ~eq(obj_in(kk), out(kk), ple3), atest = false; end
+        % Check the history
+        if ~eq(obj_in(kk).hist, out(kk).hist.inhists), atest = false; end
+        % Change the output to make sure that it is a 'real' copy
+        out(kk).setDescription('my desc');
+        if eq(obj_in(kk), out(kk), ple3), atest = false; end
+        
+      else
+        atest = algo(obj_in(kk), out(kk), pli);
+        if ~atest
+          break;
+        end  
+      end
+    end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_02
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_05.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,72 @@
+% <TestDescription>
+%
+% Tests that the <METHOD> method works with a mix of different arrays of objects as input.
+%
+% </TestDescription>
+function result = utp_05(method, obj1, obj2, obj3, algo, pli, ple3)
+  
+  % <SyntaxDescription>
+  %
+  % Tests that the <METHOD> method works with a mix of different arrays of
+  % objects as input.
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    if isempty(pli)
+      out = feval(method, obj1, obj2, obj3);
+    else
+      out = feval(method, obj1, obj2, obj3, pli);
+    end
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the number of elements in 'out' is the same as in 'mat'
+  % 2) Check that each output object contains the correct data.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    obj_in = [reshape(obj1, 1, []) reshape(obj2, 1, []) reshape(obj3, 1, [])];
+    % <AlgoCode>
+    % Check we have the correct number of outputs
+    if ~isequal(size(out), size(obj_in)), atest = false; end
+    % Check each output against the correct value
+    for kk=1:numel(obj_in)
+      
+      % extra tests for constructors
+      if utils.helper.ismember(method, utils.helper.ltpda_userclasses)
+        
+        % Check that the output is the same except the history
+        if ~eq(obj_in(kk), out(kk), ple3), atest = false; end
+        % Check the history
+        if ~eq(obj_in(kk).hist, out(kk).hist.inhists), atest = false; end
+        % Change the output to make sure that it is a 'real' copy
+        out(kk).setDescription('my desc');
+        if eq(obj_in(kk), out(kk), ple3), atest = false; end
+        
+      else
+        atest = algo(obj_in(kk), out(kk), pli);
+        if ~atest
+          break;
+        end 
+      end
+    end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_02
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_06.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,53 @@
+% <TestDescription>
+%
+% Tests that the <METHOD> method properly applies history.
+%
+% </TestDescription>
+function result = utp_06(method, obj1, pli, epl)
+  
+  % <SyntaxDescription>
+  %
+  % Test that the result of applying the <METHOD> method can be processed back.
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    if isempty(pli)
+      out  = feval(method, obj1);
+    else
+      out  = feval(method, obj1, pli);
+    end
+    mout = rebuild(out);
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the last entry in the history of 'out' corresponds to
+  %    '<METHOD>'.
+  % 2) Check that the re-built object is the same object as the input.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check the last step in the history of 'out'
+    if ~strcmp(out.hist.methodInfo.mname, method), atest = false; end
+    % The rebuilt object must be the same as 'out'
+    if ~eq(mout, out, epl), atest = false; end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_06
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_07.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,69 @@
+% <TestDescription>
+%
+% Tests that the <METHOD> method can modify the input AO.
+%
+% </TestDescription>
+function result = utp_07(method, obj1, ipl, ple1)
+  
+  % <SyntaxDescription>
+  %
+  % Test that the <METHOD> method can modify the input object by calling with no
+  % output and that the method doesn't change the input of the function
+  % notation (with a equal sign).
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    obj_modi = copy(obj1,1);
+    obj_eq   = copy(obj1,1);
+    cmd = sprintf('out = obj_eq.%s(ipl);', method);
+    eval(cmd);
+    cmd = sprintf('obj_modi.%s(ipl);', method);
+    eval(cmd);
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that 'out' and 'aeq' are now different.
+  % 2) Check that 'aeq' is not changed
+  % 3) Check that the modified input is the <METHOD> value of the copy
+  % 4) Check that out and amodi are the same
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check that 'out' and 'obj_eq' are now different.
+    if eq(out, obj_eq, ple1), atest = false; end
+    % Check that 'obj_eq' is not changed
+    if ~eq(obj_eq, obj1, ple1), atest = false; end
+    
+    switch class(obj1)
+      case 'ao'
+        if isempty(ipl) || isempty(find(ipl, 'neval'))
+        % Check that the modified input is correct
+        if ~isequal(feval(method, obj1.data.getY), obj_modi.data.getY), atest = false; end
+        end
+        % Check that out and obj_modi are the same
+        if ~eq(out, obj_modi, ple1), atest = false; end
+      otherwise
+        warning('!!! test is undefined for class %s', class(obj_modi));
+        atest = false;
+    end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_07
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_08.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,65 @@
+
+% <TestDescription>
+%
+% Test that the <METHOD> method uses the plist to get the axis.
+%
+% </TestDescription>
+function result = utp_08(method, obj1, ple1)
+  
+  % <SyntaxDescription>
+  %
+  % Test that the <METHOD> method uses the plist to get the axis.
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    plx  = plist('axis', 'X');
+    ply  = plist('axis', 'Y');
+    plxy = plist('axis', 'XY');
+    out1 = feval(method, obj1, plx);
+    out2 = feval(method, obj1, ply);
+    out3 = feval(method, obj1, plxy);
+    mout1 = rebuild(out1);
+    mout2 = rebuild(out2);
+    mout3 = rebuild(out3);
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the <METHOD> method applies to the x-axis
+  % 2) Check that the <METHOD> method applies to the y-axis
+  % 3) Check that the <METHOD> method applies to both axes
+  % 4) Check that the re-built object is the same as in 'out[1..3]'.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check each output against the correct values
+    if ~isequal(feval(method, obj1.data.getX), out1.data.getX), atest = false; end
+    if ~isequal(obj1.data.getY, out1.data.getY), atest = false; end
+    if ~isequal(obj1.data.getX, out2.data.getX), atest = false; end
+    if ~isequal(feval(method,obj1.data.getY), out2.data.getY), atest = false; end
+    if ~isequal(feval(method,obj1.data.getX), out3.data.getX), atest = false; end
+    if ~isequal(feval(method,obj1.data.getY), out3.data.getY), atest = false; end
+    % Check the re-built objects
+    if ~eq(mout1, out1, ple1), atest = false; end
+    if ~eq(mout2, out2, ple1), atest = false; end
+    if ~eq(mout3, out3, ple1), atest = false; end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_08
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_09.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,85 @@
+% <TestDescription>
+%
+% Test the shape of the data in AOs.
+%
+% </TestDescription>
+function result = utp_09(method, obj1, obj2)
+  
+  % <SyntaxDescription>
+  %
+  % Test that the <METHOD> method keeps the data shape of the input object. The
+  % input AO data must be an array with row data and/or column data.
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    
+    if iscolumnvector(obj1) == iscolumnvector(obj2)
+      warning('!!! Incorrect inputs. Give a column and a row vector.');
+      stest = false;
+    else
+      out1 = feval(method, obj1);
+      out2 = feval(method, obj2);
+      % </SyntaxCode>
+      stest = true;
+    end
+    
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the shape of the data doesn't change.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check the shape of the output data
+
+    atest = false;
+    
+    if iscolumnvector(out1) && iscolumnvector(obj1)
+      atest = true;
+    end
+    
+    if isrowvector(out1) && isrowvector(obj1)
+      atest = true;
+    end
+    
+    
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_09
+
+function res = iscolumnvector(obj)
+  
+  if size(obj.data.y, 1)>=1 && size(obj.data.y,2)==1
+    res = true;
+  else
+    res = false;
+  end
+  
+end
+
+
+function res = isrowvector(obj)
+  
+  if size(obj.data.y, 2)>=1 && size(obj.data.y,1)==1
+    res = true;
+  else
+    res = false;
+  end
+  
+end

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_10.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,57 @@
+% <TestDescription>
+%
+% Check that the <METHOD> method pass back the output objects to a list of
+% output variables or to a single variable.
+%
+% </TestDescription>
+function result = utp_10(method, obj1, obj2, ple2)
+  
+  % <SyntaxDescription>
+  %
+  % Call the method with a list of output variables and with a single output
+  % variable. Additionaly check that the rebuild method works on the output.
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    [o1, o2] = feval(method, obj1, obj2);
+    o3  = feval(method, obj1, obj2);
+    mout1 = rebuild(o1);
+    mout2 = rebuild(o2);
+    mout3 = rebuild(o3);
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the output contains the right number of objects
+  % 2) Check that the 'rebuild' method produces the same object as 'out'.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check the number of outputs
+    if numel(o1) ~=1, atest = false; end
+    if numel(o2) ~=1, atest = false; end
+    if numel(o3) ~=2, atest = false; end
+    % Check the rebuilding of the object
+    if ~eq(o1, mout1, ple2), atest = false; end
+    if ~eq(o2, mout2, ple2), atest = false; end
+    if ~eq(o3, mout3, ple2), atest = false; end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_10

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_108.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,64 @@
+
+% <TestDescription>
+%
+% Test that the <METHOD> method uses the plist to get the axis. This is
+% intended to test methods like ao/mean and ao/std which return different
+% data types depending on which axis is selected.
+%
+% </TestDescription>
+function result = utp_108(method, obj1, ple1)
+  
+  % <SyntaxDescription>
+  %
+  % Test that the <METHOD> method uses the plist to get the axis.
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    plx  = plist('axis', 'X');
+    ply  = plist('axis', 'Y');
+    plxy = plist('axis', 'XY');
+    out1 = feval(method, obj1, plx);
+    out2 = feval(method, obj1, ply);
+    out3 = feval(method, obj1, plxy);
+    mout1 = rebuild(out1);
+    mout2 = rebuild(out2);
+    mout3 = rebuild(out3);
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the <METHOD> method applies to the x-axis
+  % 2) Check that the <METHOD> method applies to the y-axis
+  % 3) Check that the <METHOD> method applies to both axes
+  % 4) Check that the re-built object is the same as in 'out[1..3]'.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check each output against the correct values
+    if ~isequal(feval(method,obj1.data.getX), out1.data.getY), atest = false; end
+    if ~isequal(feval(method,obj1.data.getY), out2.data.getY), atest = false; end
+    if ~isequal(feval(method,obj1.data.getY), out3.data.getY), atest = false; end
+    % Check the re-built objects
+    if ~eq(mout1, out1, ple1), atest = false; end
+    if ~eq(mout2, out2, ple1), atest = false; end
+    if ~eq(mout3, out3, ple1), atest = false; end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_108
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_11.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,56 @@
+% <TestDescription>
+%
+% Check that the <METHOD> method pass back the output objects to a list of
+% output variables or to a single variable.
+%
+% </TestDescription>
+function result = utp_11(method, obj1, ple1, varargin)
+  
+  % <SyntaxDescription>
+  %
+  % Call the method with a list of output variables and with a single output
+  % variable. Additionaly check that the rebuild method works on the output.
+  %
+  % </SyntaxDescription>
+  
+  if ~isempty(varargin)
+    pli = varargin{1};
+  else
+    pli = [];
+  end
+  
+  try
+    % <SyntaxCode>
+    obj1 = obj1.setPlotinfo(plist('color', 'r'));
+    if isempty(pli)
+      o1 = feval(method, obj1);
+    else
+      o1 = feval(method, obj1, pli);
+    end
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the output contains the same plotinfo plist
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    if ~eq(obj1(1).plotinfo, o1(1).plotinfo, ple1), atest = false; end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_30
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_12.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,61 @@
+% <TestDescription>
+%
+% Check that the errors are cleared for this method.
+%
+% </TestDescription>
+function result = utp_12(method, obj1, ple1, varargin)
+  
+  % <SyntaxDescription>
+  %
+  % Call the method with a list of output variables and with a single output
+  % variable. Additionaly check that the rebuild method works on the output.
+  %
+  % </SyntaxDescription>
+  
+  if ~isempty(varargin)
+    pli = varargin{1};
+  else
+    pli = [];
+  end
+  
+  try
+    % <SyntaxCode>
+    if isa(obj1.data, 'data2D')
+      obj1 = obj1.setDx(obj1.x);
+    end
+    obj1 = obj1.setDy(obj1.y);
+    if isempty(pli)
+      o1 = feval(method, obj1);
+    else
+      o1 = feval(method, obj1, pli);
+    end
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the output has no error fields
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % check which axis the method was applied to, if any
+    ax = o1.hist.plistUsed.find('axis');
+    % <AlgoCode>
+    if any('X'==upper(ax)) && ~isempty(o1.dx), atest = false; end
+    if any('Y'==upper(ax)) && ~isempty(o1.dy), atest = false; end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_12
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_208.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,59 @@
+
+% <TestDescription>
+%
+% Test that the <METHOD> method uses the plist to get the axis. This is
+% intended to test methods like ao/max and ao/min which only allow 'x' and
+% 'y' choices.
+%
+% </TestDescription>
+function result = utp_208(method, obj1, ple1)
+  
+  % <SyntaxDescription>
+  %
+  % Test that the <METHOD> method uses the plist to get the axis.
+  %
+  % </SyntaxDescription>
+  
+  try
+    % <SyntaxCode>
+    plx  = plist('axis', 'X');
+    ply  = plist('axis', 'Y');
+    out1 = feval(method, obj1, plx);
+    out2 = feval(method, obj1, ply);
+    mout1 = rebuild(out1);
+    mout2 = rebuild(out2);
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the <METHOD> method applies to the x-axis
+  % 2) Check that the <METHOD> method applies to the y-axis
+  % 3) Check that the <METHOD> method applies to both axes
+  % 4) Check that the re-built object is the same as in 'out[1..3]'.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check each output against the correct values
+    if ~isequal(feval(method,obj1.data.getX), out1.data.getX), atest = false; end
+    if ~isequal(feval(method,obj1.data.getY), out2.data.getY), atest = false; end
+    % Check the re-built objects
+    if ~eq(mout1, out1, ple1), atest = false; end
+    if ~eq(mout2, out2, ple1), atest = false; end
+    % </AlgoCode>
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename);
+end % END UTP_208
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_60.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,67 @@
+
+% <TestDescription>
+%
+% Tests that the constructor method doesn't apply history to the read
+% MAT-file constructor.
+%
+% </TestDescription>
+function result = utp_60(cl, obj1, ple1)
+  
+  % <SyntaxDescription>
+  %
+  % Tests that the constructor method doesn't apply history to the read
+  % MAT-file constructor.
+  %
+  % </SyntaxDescription>
+  
+  msg = '';
+  try
+    % <SyntaxCode>
+    filename = 'obj.mat';
+    ss = feval(cl, obj1);
+    save(ss, filename);
+    
+    out  = feval(cl, filename);
+    mout = rebuild(out);
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    msg = err.message;
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the history is the same as the history of the saved
+  %    object. Because save and load shouldn't add a history step.
+  % 2) Check that the 'rebuild' method produces the same object as 'out'.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check that the saved and loaded objects are the same
+    if ~eq(out, ss)
+      msg = ['The saved and loaded objects are not equal: ' lastwarn];
+      atest = false;
+    end
+    % Check the rebuilt object
+    if ~eq(mout, out, ple1)
+      msg = ['The original and rebuilt objects are not equal: ' lastwarn];
+      atest = false;
+    end
+    % </AlgoCode>
+    delete(filename);
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename, msg);
+end % END UTP_08
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/utp_1.1/generic_utps/utp_61.m	Tue Dec 06 18:42:11 2011 +0100
@@ -0,0 +1,67 @@
+% <TestDescription>
+%
+% Tests that the constructor properly applies history to the read
+% XML-file constructor.
+%
+% </TestDescription>
+function result = utp_61(cl, obj1, ple2)
+  
+  % <SyntaxDescription>
+  %
+  % Tests that the constructor properly applies history to the read
+  % XML-file constructor.
+  %
+  % </SyntaxDescription>
+  
+  msg = '';
+  try
+    % <SyntaxCode>
+    filename = 'obj.xml';
+    amat = feval(cl, obj1);
+    save(amat, filename);
+    
+    out  = feval(cl, filename);
+    mout = rebuild(out);
+    % </SyntaxCode>
+    stest = true;
+  catch err
+    msg = err.message;
+    disp(err.message)
+    stest = false;
+  end
+  
+  % <AlgoDescription>
+  %
+  % 1) Check that the history is the same as the history of the saved
+  %    object. Because save and load shouldn't add a history step.
+  % 2) Check that the 'rebuild' method produces the same object as 'out'.
+  %
+  % </AlgoDescription>
+  
+  atest = true;
+  if stest
+    % <AlgoCode>
+    % Check the last step in the history of 'out'
+    if ~eq(out, amat)
+      msg = ['The original and rebuilt objects are not equal: ' lastwarn];
+      atest = false;
+    end
+    
+    % Check the rebuilt object
+    for kk = 1:numel(out)
+      if ~eq(mout(kk), out(kk), ple2)
+        msg = ['The original and rebuilt objects are not equal: ' lastwarn];
+        atest = false;
+      end
+    end
+    % </AlgoCode>
+    delete(filename);
+  else
+    atest = false;
+  end
+  
+  % Return a result structure
+  dd = dbstack;
+  mfilename = dd(2).file(1:end-2);  
+  result = utp_prepare_result(atest, stest, dbstack, mfilename, msg);
+end % END UTP_09