bcpm 0.11

data/lib/bcpm/socket.rb

@@ -0,0 +1,8 @@
+require 'socket'
+
+unless Socket.respond_to? :hostname
+  # :nodoc: Monkey-patch Socket to add hostname method for old Rubies.
+  def Socket.hostname
+    @__hostname ||= `hostname`.strip
+  end
+end

data/lib/bcpm/tests/assertion_error.rb

@@ -0,0 +1,13 @@
+# :nodoc: namespace
+module Bcpm
+
+# :nodoc: namespace
+module Tests
+
+# Raised when a test assertion fails.
+class AssertionError < RuntimeError
+end  # class Bcpm::Tests::AssertionError
+
+end  # namespace Bcpm::Tests
+
+end  # namespace Bcpm

data/lib/bcpm/tests/assertions.rb

@@ -0,0 +1,102 @@
+# :nodoc: namespace
+module Bcpm
+  
+# :nodoc: namespace
+module Tests
+  
+# Assertions for match tests.
+module Assertions  
+  # Fails unless the match was won.
+  def should_win
+    return if match.winner == :a
+    raise Bcpm::Tests::AssertionError, "Player was expected to win, but didn't! " + match.outcome
+  end
+
+  # Fails unless the match was won, and the Reason: line includes the argument text. 
+  def should_win_by(reason)
+    should_win
+    
+    return if match.reason.index(reason)
+    raise Bcpm::Tests::AssertionError, "Player was expected to win by #{reason} and didn't. " +
+                                       match.reason
+  end
+
+  # Fails unless the match was lost.
+  def should_lose
+    return if match.winner == :b
+    raise Bcpm::Tests::AssertionError, "Player was expected to lose, but didn't! " + match.outcome
+  end
+
+  # Fails unless the match was lost, and the Reason: line includes the argument text. 
+  def should_lose_by(reason)
+    should_lose
+    
+    return if match.reason.index(reason)
+    raise Bcpm::Tests::AssertionError, "Player was expected to win by #{reason} and didn't. " +
+                                       match.reason
+  end
+
+  # Fails if the player code threw any exception.
+  def should_not_throw
+    if match.output.index(/\n(\S*)Exception(.*?)\n\S/m)
+      raise Bcpm::Tests::AssertionError, "Player should not have thrown exceptions! " +
+          "It threw #{$1}Exception#{$2}"
+    end
+    if match.chatter.index(/\n(\S*)Exception(.*?)\n\S/m)
+      raise Bcpm::Tests::AssertionError, "Player should not have thrown exceptions! " +
+          "It threw #{$1}Exception#{$2}"
+    end
+  end
+  
+  # Always fails. Useful for obtaining the game log.
+  def fail(reason = 'Test case called fail!')
+    raise Bcpm::Tests::AssertionError, reason
+  end
+  
+  # Fails unless a unit's output matches the given regular expression.
+  #
+  # If a block is given, yields to the block for every match.
+  def should_match_unit_output(pattern)
+    matched = false
+    
+    match.output_lines.each do |line|
+      next unless unit_output = _parse_unit_output(line)
+      if match = pattern.match(unit_output[:output])
+        matched = true
+        if Kernel.block_given?
+          yield unit_output, match
+        else
+          break
+        end
+      end
+    end
+        
+    raise Bcpm::Tests::AssertionError, "No unit output matched #{pattern.inspect}!" unless matched
+  end
+  
+  # Parses a unit's console output (usually via System.out.print*).
+  #
+  # If the given line looks like a unit's console output, returns a hash with the following keys:
+  #   :team:: 'A' or 'B' (should always be 'A', unless the case enables team B's console output)
+  #   :unit_type:: e.g., 'ARCHON'
+  #   :unit_id:: the robot ID of the unit who wrote the line, parsed as an Integer
+  #   :round:: the round when the line was output, parsed as an Integer
+  #   :output:: the (first line of the) string that the unit produced
+  #
+  # If the line doesn't parse out, returns nil.
+  def _parse_unit_output(line)
+    line_match = /^\[([AB])\:([A-Z]+)\#(\d+)\@(\d+)\](.*)$/.match line
+    return nil unless line_match
+    {
+      :team => line_match[1],
+      :unit_type => line_match[2],
+      :unit_id => line_match[3].to_i,
+      :round => line_match[4].to_i,
+      :output => line_match[5]
+    }
+  end
+end
+
+end  # namespace Bcpm::Tests
+  
+end  # namespace Bcpm

data/lib/bcpm/tests/case_base.rb

@@ -0,0 +1,166 @@
+# :nodoc: namespace
+module Bcpm
+
+# :nodoc: namespace
+module Tests
+  
+# Base class for test cases.
+#
+# Each test case is its own anonymous class.
+class CaseBase
+  class <<self
+    # Called before any code is evaluated in the class context.
+    def _setup
+      @map = nil
+      @suite_map = false
+      @vs = nil
+      @side = :a
+      @match = nil      
+      @options = {}
+      @env = Bcpm::Tests::Environment.new
+      @env_used = false
+      
+      @tests = []
+      @environments = []
+      @matches = []
+    end
+    
+    # Called after all code is evaluated in the class context.
+    def _post_eval
+      @environments << @env if @env_used
+      @env = nil
+      @options = nil
+    end
+    
+    # Called by public methods before they change the environment.
+    def _env_change
+      if @env_used
+        @environments << @env
+        @env = Bcpm::Tests::Environment.new
+        @env_used = false
+      end
+    end
+
+    # Set the map for following matches.
+    def map(map_name)
+      @map = map_name.dup.to_s
+      @suite_map = false
+    end
+    
+    # Set the map for the following match. Use a map in the player's test suite.
+    def suite_map(map_name)
+      @map = map_name.dup.to_s
+      @suite_map = true
+    end
+  
+    # Set the enemy for following matches.
+    def vs(player_name)
+      @vs = player_name.dup.to_s
+    end
+    
+    # Set our side for the following matches.
+    def side(side)
+      @side = side.to_s.downcase.to_sym
+    end
+    
+    # Set a simulation option.
+    def option(key, value)
+      key = Bcpm::Match.engine_options[key.to_s] if key.kind_of? Symbol
+      
+      if value.nil?
+        @options.delete key
+      else
+        @options[key] = value
+      end
+    end
+    
+    # Replaces a class implementation file (.java) with another one (presumably from tests).
+    def replace_class(target, source)
+      _env_change
+      @env.file_op [:file, target, source]
+    end
+    
+    # Replaces all fragments labeled with target_fragment in target_class with another fragment.
+    def replace_code(target_class, target_fragment, source_class, source_fragment)
+      _env_change
+      @env.file_op [:fragment, [target_class, target_fragment], [source_class, source_fragment]]
+    end
+    
+    # Redirects all method calls using a method name to a static method.    
+    #
+    # Assumes the target method is a member method, and passes "this" to the static method.
+    def stub_member_call(source, target)
+      _env_change
+      @env.patch_op [:stub_member, target, source]
+    end
+
+    # Redirects all method calls using a method name to a static method.
+    #
+    # Assumes the target method is a static method, and ignores the call target.
+    def stub_static_call(source, target)
+      _env_change
+      @env.patch_op [:stub_static, target, source]
+    end
+  
+    # Create a test match. The block contains test cases for the match.
+    def match(&block)
+      begin
+        @env_used = true
+        map = @suite_map ? @env.suite_map_path(@map) : @map
+        @match = Bcpm::Tests::TestMatch.new @side, @vs, map, @env, @options
+        self.class_eval(&block)
+        @matches << @match
+      ensure
+        @match = nil
+      end
+    end
+
+    # Create a test match.
+    def it(label, &block)
+      raise "it can only be called within match blocks!" if @match.nil?        
+      @tests << self.new(label, @match, block)
+    end
+
+    # All the environments used in the tests.
+    attr_reader :environments
+    # All the matches used in the tests.
+    attr_reader :matches
+    # All test cases.
+    attr_reader :tests
+  end
+  
+  # Descriptive label for the test case.
+  attr_reader :label
+  # Test match used by the test case.
+  attr_reader :match
+  
+  # Called by match.
+  def initialize(label, match, block)
+    @label = label
+    @match = match
+    @block = block
+  end
+  
+  # User-readable description of test conditions.
+  def description
+    "#{match.description} #{label}"
+  end
+
+  # Verifies the match output against the test case.
+  #
+  # Returns nil for success, or an AssertionError exception if the case failed.
+  def check_output
+    begin
+      self.instance_eval &@block
+      return nil
+    rescue Bcpm::Tests::AssertionError => e
+      return e
+    end
+  end
+  
+  include Bcpm::Tests::Assertions
+end  # class Bcpm::Tests::CaseBase
+
+end  # namespace Bcpm::Tests
+
+end  # namespace Bcpm

data/lib/bcpm/tests/environment.rb

@@ -0,0 +1,256 @@
+require 'English'
+require 'fileutils'
+require 'socket'
+
+# :nodoc: namespace
+module Bcpm
+
+# :nodoc: namespace
+module Tests
+  
+# A match run for simulation purposes.
+#
+# Each test case is its own anonymous class.
+class Environment
+  # Name of the player container for the enviornment.
+  attr_reader :player_name
+  
+  # The build log, if the build happened.
+  attr_reader :build_log
+
+  # Creates a new environment blueprint.
+  #
+  # Args:
+  #   prebuilt_name:: if given, the created blueprint points to an already-built environment
+  def initialize(prebuilt_name = nil)
+    @file_ops = [] 
+    @patch_ops = []
+    @build_log = nil
+
+    if prebuilt_name
+      @player_name = prebuilt_name
+      @available = true
+    else
+      @player_name = self.class.new_player_name
+      @available = false
+    end
+  end
+  
+  # Puts together an environment according to the blueprint.
+  def setup(suite_path)
+    return true if @available
+    
+    begin
+      test_player = File.basename suite_path
+
+      @player_path = Bcpm::Player.checkpoint test_player, 'master', player_name
+      raise "Failed to checkpoint player at #{suite_path}" unless @player_path
+      @player_src = Bcpm::Player.package_path(@player_path)
+            
+      file_ops
+      patch_ops
+      
+      unless build
+        print "Test environment build failed! Some tests will not run!\n"
+        print "#{@build_log}\n"
+        return false
+      end
+    rescue Exception => e
+      print "Failed setting up test environment! Some tests will not run!\n"
+      print "#{e.class.name}: #{e.to_s}\n#{e.backtrace.join("\n")}\n\n"
+      return false
+    end
+    @available = true    
+  end
+  
+  # True if the environment has been setup and can be used to run tests.
+  def available? 
+    @available
+  end
+  
+  # Undoes the effects of setup.
+  def teardown
+    Bcpm::Player.uninstall player_name
+    @available = false
+  end
+  
+  # Path to the maps in the test suite for the player.
+  def suite_map_path(map_name)
+    File.join Bcpm::Player.local_root, player_name, 'suite', 'maps',
+              map_name + '.xml'
+  end
+  
+  # Queue an operation that adds a file.
+  def file_op(op)
+    @file_ops << op
+  end
+  
+  # Queue an operation that patches all source files.
+  def patch_op(op)
+    @patch_ops << op
+  end
+  
+  # Copies files from the test suite to the environment.
+  #  
+  # Called by setup, uses its environment.
+  def file_ops
+    @file_ops.each do |op|
+      op_type, target, source = *op
+      
+      if op_type == :fragment
+        target, target_fragment = *target
+        source, source_fragment = *source
+      end
+      
+      target = "#{@player_name}.#{target}"
+      source = "#{@player_name}.#{source}"
+      file_path = java_path @player_src, source
+      
+      next unless File.exist? file_path
+      source_contents = File.read file_path
+
+      case op_type        
+      when :file
+        contents = source_contents
+      when :fragment
+        next unless fragment_match = fragment_regexp(source_fragment).match(source_contents)
+        contents = fragment_match[0]
+      end
+  
+      source_pkg = java_package source
+      target_pkg = java_package target
+      unless source_pkg == target_pkg
+        contents.gsub! /(^|[^A-Za-z0-9_.])#{source_pkg}([^A-Za-z0-9_]|$)/, "\\1#{target_pkg}\\2"
+      end
+  
+      source_class = java_class source
+      target_class = java_class target
+      unless source_class == target_class
+        contents.gsub! /(^|[^A-Za-z0-9_])#{source_class}([^A-Za-z0-9_]|$)/, "\\1#{target_class}\\2"
+      end
+        
+      file_path = java_path @player_src, target
+      
+      case op_type
+      when :file
+        next unless File.exist?(File.dirname(file_path))
+      when :fragment
+        next unless File.exist?(file_path)
+        source_contents = File.read file_path
+        # Not using a string because source code might contain \1 which would confuse gsub.
+        source_contents.gsub! fragment_regexp(target_fragment) do |match|
+          "#{$1}\n#{contents}\n#{$3}"
+        end
+        contents = source_contents
+      end
+      
+      File.open(file_path, 'wb') { |f| f.write contents }  
+    end
+  end
+  
+  # Applies the patch operations to the source code in the environment.
+  #
+  # Called by setup, uses its environment.
+  def patch_ops
+    return if @patch_ops.empty?
+    
+    Dir.glob(File.join(@player_src, '**', '*.java')).each do |file|
+      old_contents = File.read file
+      lines = old_contents.split("\n")
+
+      stubs_enabled = true
+
+      0.upto(lines.count - 1) do |i|
+        line = lines[i]
+        if directive_match = /^\s*\/\/\$(.*)$/.match(line)
+          directive = directive_match[1]
+          case directive.strip.downcase
+          when '+stubs', '-stubs'
+            stubs_enabled = directive[0] == ?+
+          end
+        else
+          @patch_ops.each do |op|
+            op_type, target, source = *op
+      
+            case op_type
+            when :stub_member
+              if stubs_enabled
+                line.gsub!(/(^|[^A-Za-z0-9_.])([A-Za-z0-9_.]*\.)?#{source}\(/) do |match|
+                  arg = ($2.nil? || $2.empty?) ? 'this' : $2[0..-2]
+                  "#{$1}#{player_name}.#{target}(#{arg}, "
+                end
+              end
+            when :stub_static
+              if stubs_enabled
+                line.gsub! /(^|[^A-Za-z0-9_.])([A-Za-z0-9_.]*\.)?#{source}\(/,
+                           "\\1#{player_name}.#{target}("
+              end
+            end
+          end
+        end
+      end
+      contents = lines.join("\n")
+      File.open(file, 'wb') { |f| f.write contents } unless contents == old_contents
+    end
+  end
+  
+  # Builds the binaries for the player in this environment.
+  #
+  # Called by setup, uses its environment.
+  #
+  # Returns true for success, false for failure.
+  def build
+    uid = "bcpmbuild_#{Socket.hostname}_#{(Time.now.to_f * 1000).to_i}_#{$PID}"
+    tempdir = File.expand_path File.join(Dir.tmpdir, 'bcpm', uid)
+    FileUtils.mkdir_p tempdir
+    build_log = File.join tempdir, 'build.log'
+    build_file = File.join tempdir, 'build.xml'
+    Bcpm::Match.write_build build_file, 'bc.conf'
+      
+    Bcpm::Match.run_build_script tempdir, build_file, build_log, 'build'
+    @build_log = File.exist?(build_log) ? File.open(build_log, 'rb') { |f| f.read } : ''
+    FileUtils.rm_rf tempdir
+    
+    @build_log.index("\nBUILD SUCCESSFUL\n") ? true : false
+  end
+  
+  # Regular expression matching a code fragment.
+  #
+  # The expression captures three groups: the fragment start marker, the fragment, and the fragment
+  # end marker.
+  def fragment_regexp(label)
+    /^([ \t]*\/\/\$[ \t]*\+mark\:[ \t]*#{label}\s)(.*)(\n[ \t]*\/\/\$[ \t]*\-mark\:[ \t]*#{label}\s)/m
+  end
+  
+  # Path to .java source for a class.
+  def java_path(package_path, class_name)
+    File.join(File.dirname(package_path), class_name.gsub('.', '/') + '.java')
+  end
+  
+  # Package for a Java class given its fully qualified name.
+  def java_package(class_name)
+    index = class_name.rindex '.'
+    index ? class_name[0, index] : ''
+  end
+
+  # Short class name for a Java class given its fully qualified name.
+  def java_class(class_name)
+    index = class_name.rindex '.'
+    index ? class_name[index + 1, class_name.length - index - 1] : class_name
+  end
+
+  # A player name guaranteed to be unique across the systme.
+  def self.new_player_name
+    # NOTE: Java doesn't like .s in it package names :)
+    host = Socket.hostname.gsub(/[^A-Za-z_]/, '_')
+    @prefix ||=
+        "bcpmtest_#{host}_#{(Time.now.to_f * 1000).to_i}_#{$PID}"
+    @counter ||= 0
+    @counter += 1
+    "#{@prefix}_#{@counter}"
+  end
+end  # class Bcpm::Tests::TestMatch
+
+end  # namespace Bcpm::Tests
+
+end  # namespace Bcpm