evoasm 0.0.2.pre7 → 0.1.0.pre2

data/test/helpers/population_helper.rb

@@ -0,0 +1,128 @@
+require 'evoasm'
+require 'evoasm/x64'
+require 'tmpdir'
+require 'pp'
+require 'json'
+
+module PopulationHelper
+
+  def set_default_parameters
+    @examples = {
+      1 => 2,
+      2 => 3,
+      3 => 4
+    }
+    @instruction_names = Evoasm::X64.instruction_names(:gp, :rflags)
+    @deme_size = 1200
+    @parameters = %i(reg0 reg1 reg2 reg3)
+    @recur_limit = 0
+    @deme_count = 1
+    @mutation_rate = 0.02
+  end
+
+  def new_population(architecture = :x64)
+    parameters = Evoasm::Population::Parameters.new architecture do |p|
+      p.instructions = @instruction_names
+      p.kernel_size = @kernel_size
+      p.program_size = @program_size
+      p.deme_size = @deme_size
+      p.deme_count = @deme_count
+      p.examples = @examples
+      p.parameters = @parameters
+      p.domains = @domains if @domains
+      p.seed = @seed if @seed
+      p.recur_limit = @recur_limit
+      p.mutation_rate = @mutation_rate
+    end
+
+    Evoasm::Population.new parameters
+  end
+
+  def start(loss = 0.0, min_generations: 0, max_generations: 1024, &block)
+    @population = new_population
+    @found_program = nil
+
+    @found_program, loss = @population.run(loss: loss, min_generations: min_generations, max_generations: max_generations) do
+      best_loss = @population.best_loss
+      if best_loss == Float::INFINITY
+        @population.seed
+      end
+
+      if block
+        block[@population.summary]
+      end
+
+      @population.plot
+    end
+  end
+
+  module Tests
+    def found_program
+      @found_program
+    end
+
+    def examples
+      @examples
+    end
+
+    def test_program_found
+      refute_nil found_program, "no solution found"
+      assert_kind_of Evoasm::Program, found_program
+    end
+
+    def assert_runs_examples(program)
+      assert_equal examples.values, program.run_all(*examples.keys)
+      p examples.keys
+      p program.run_all(*examples.keys)
+    end
+
+    def test_program_to_gv
+      filename = Dir::Tmpname.create(['evoasm_gv_test', '.png']) {}
+      found_program.to_gv.save(filename)
+      assert File.exist?(filename)
+    end
+
+    def test_program_run_all
+      assert_runs_examples found_program
+    end
+
+    def random_code
+      # Fill registers with random values
+
+      ary = Array.new(10) { rand }
+      ary.sort! if rand < 0.5
+      ary.map! { |e| (e * rand(10_000)).to_i } if rand < 0.5
+    end
+
+    def test_consistent_progress
+
+      5.times do
+        @seed = Array.new(Evoasm::PRNG::SEED_SIZE) { rand(10000) }
+
+        run_summaries = []
+
+        run_count = 3
+        run_count.times do
+          random_code
+          summaries = []
+
+          start(0.5, min_generations: 10, max_generations: 20) do |summary|
+            summaries << summary
+          end
+
+          run_summaries << summaries
+        end
+
+        assert_equal run_count, run_summaries.size
+
+        #run_summaries.each_with_index do |s, i|
+        #  File.write("/tmp/t#{i}.txt", s.pretty_inspect)
+        #end
+
+        run_summaries.uniq.tap do |uniq|
+          assert_equal [run_summaries.first], uniq
+        end
+      end
+    end
+  end
+end

data/test/helpers/test_helper.rb

@@ -0,0 +1 @@
+require 'evoasm'

data/test/helpers/x64_helper.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+require 'evoasm/x64'
+
+module X64Helper
+  def assert_disassembles_to(exp_disasm, instruction_name, **parameters)
+    exp_disasm.force_encoding('ASCII-8BIT')
+    act_disasm = disassemble(Evoasm::X64.encode(instruction_name, parameters))
+    assert_equal exp_disasm, act_disasm
+  end
+
+  def assert_assembles_to(exp_asm, inst_name, **params)
+    exp_asm.force_encoding('ASCII-8BIT')
+    act_asm = assemble(inst_name, **params)
+    assert_equal exp_asm, act_asm
+  end
+
+  def disassemble(asm)
+    Evoasm::X64.disassemble(asm).first.join(' ')
+  end
+
+  def assemble(instruction_name, **parameters)
+    Evoasm::X64.encode(instruction_name, parameters)
+  end
+end

data/test/integration/bitwise_reverse_test.rb

@@ -0,0 +1,41 @@
+require 'evoasm/test'
+require 'evoasm/population'
+require 'population_helper'
+
+
+module Evoasm
+  class BitwiseReverseTest < Minitest::Test
+    include PopulationHelper
+    include PopulationHelper::Tests
+
+    def setup
+      set_default_parameters
+
+      @instruction_names = Evoasm::X64.instruction_names(:gp, :rflags)
+      @examples = {
+        0b00000000 => 0b00000000,
+        0b10000000 => 0b00000001,
+        0b01000000 => 0b00000010,
+        0b01100000 => 0b00000110,
+        0b00010000 => 0b00001000,
+        0b00001000 => 0b00010000,
+        0b00000110 => 0b01100000,
+      }
+      @kernel_size = 30
+      @program_size = 2
+      @deme_count = 2
+      @parameters = %i(reg0 reg1 reg2 reg3)
+      @mutation_rate = 0.5
+
+      start
+    end
+
+
+    def test_program_size
+      assert_equal 1, found_program.size
+    end
+
+    def test_program_run
+    end
+  end
+end

data/test/integration/gcd_test.rb

@@ -0,0 +1,52 @@
+require 'evoasm/test'
+require 'evoasm/population'
+require 'evoasm/prng'
+require 'population_helper'
+
+Evoasm.log_level = :warn
+require 'pp'
+module Search
+  class GCDTest < Minitest::Test
+    include PopulationHelper
+    include PopulationHelper::Tests
+
+    SEED = Array.new(Evoasm::PRNG::SEED_SIZE) { rand(10000) }
+
+    def setup
+      set_default_parameters
+
+      @instruction_names = Evoasm::X64.instruction_names(:gp, :rflags)
+
+      @examples = {
+        [5, 1] => 1,
+        [15, 5] => 5,
+        [8, 2] => 2,
+        [8, 4] => 4,
+        [8, 6] => 2,
+        [16, 8] => 8
+      }
+
+      @seed = SEED
+      @kernel_size = 20
+      @program_size = 5
+      @mutation_rate = 0.0
+      @deme_count = 5
+      @recur_limit = 100
+      #@deme_size = 5000
+      #@mutation_rate = 0.2
+      @parameters = %i(reg0 reg1 reg2 reg3)
+
+      unless self.name == 'test_consistent_progress'
+        start
+      end
+    end
+
+    make_my_diffs_pretty!
+
+    def test_program_run
+      # should generalize (i.e. give correct answer for non-training data)
+      #assert_equal 2, found_program.run(16, 6)
+      #assert_equal 1, found_program.run(15, 2)
+    end
+  end
+end

data/test/integration/popcnt_test.rb

@@ -0,0 +1,46 @@
+require 'evoasm/test'
+require 'evoasm/population'
+require 'population_helper'
+
+module Evoasm
+  class PopcntTest < Minitest::Test
+    include PopulationHelper
+    include PopulationHelper::Tests
+
+    def setup
+      set_default_parameters
+
+      @instruction_names = Evoasm::X64.instruction_names(:gp, :rflags)
+      @examples = {
+        0b0 => 0,
+        0b1 => 1,
+        0b110 => 2,
+        0b101 => 2,
+        0b111 => 3,
+        0b100 => 1,
+        0b101010 => 3,
+        0b1010 => 2,
+        0b10000 => 1,
+        0b100001 => 2,
+        0b101011 => 4
+      }
+      @kernel_size = 1
+      @program_size = 1
+      @parameters = %i(reg0 reg1 reg2 reg3)
+
+      start
+    end
+
+
+    def test_program_size
+      assert_equal 1, found_program.size
+    end
+
+    def test_program_run
+      # should generalize (i.e. give correct answer for non-training data)
+      assert_equal 2, found_program.run(0b1001)
+      assert_equal 1, found_program.run(0b1000)
+      assert_equal 3, found_program.run(0b1101)
+    end
+  end
+end

data/test/integration/sym_reg_test.rb

@@ -0,0 +1,68 @@
+require 'evoasm/test'
+require 'evoasm/population'
+require 'population_helper'
+
+#Evoasm.min_log_level = :info
+
+module Evoasm
+  class SymRegTest < Minitest::Test
+    include PopulationHelper
+    include PopulationHelper::Tests
+
+    def setup
+      set_default_parameters
+
+      @instruction_names = Evoasm::X64.instruction_names(:xmm).grep /(add|mul|sqrt).*?sd/
+      @examples = {
+        0.0 => 0.0,
+        0.5 => 1.0606601717798212,
+        1.0 => 1.7320508075688772,
+        1.5 => 2.5248762345905194,
+        2.0 => 3.4641016151377544,
+        2.5 => 4.541475531146237,
+        3.0 => 5.744562646538029,
+        3.5 => 7.0622234459127675,
+        4.0 => 8.48528137423857,
+        4.5 => 10.00624804809475,
+        5.0 => 11.61895003862225
+      }
+
+      @kernel_size = 10
+      @program_size = 1
+      @parameters = %i(reg0 reg1 reg2 reg3)
+      regs = %i(xmm0 xmm1 xmm2 xmm3)
+      @domains = {
+        reg0: regs,
+        reg1: regs,
+        reg2: regs,
+        reg3: regs
+      }
+
+      start
+    end
+
+    def test_program_size
+      assert_equal 1, found_program.size
+    end
+
+    def test_intron_elimination
+      disasms = found_program.disassemble
+
+      program = found_program.eliminate_introns
+      assert_runs_examples program
+      refute_equal program, found_program
+
+      program.disassemble.each_with_index do |disasm, index|
+        assert_operator disasm.size, :<=, disasms[index].size
+      end
+    end
+
+    def test_program_run
+      # should generalize (i.e. give correct answer for non-training data)
+      p found_program.run_all(*@examples.keys)
+      assert_equal 31.937438845342623, found_program.run(10.0)
+      assert_equal 36.78314831549904, found_program.run(11.0)
+      assert_equal 41.8568990729127, found_program.run(12.0)
+    end
+  end
+end

data/test/unit/evoasm/buffer_test.rb

@@ -0,0 +1,48 @@
+require 'evoasm/test'
+require 'evoasm/x64'
+require 'evoasm/buffer'
+
+module Evoasm
+  class BufferTest < Minitest::Test
+    def setup
+      @mmap_buffer = Buffer.new(1024, :mmap)
+      @malloc_buffer = Buffer.new(1024, :malloc)
+    end
+
+    def test_type
+      assert_equal :mmap, @mmap_buffer.type
+      assert_equal :malloc, @malloc_buffer.type
+    end
+
+    def test_capacity
+      assert_equal 1024, @mmap_buffer.capacity
+      assert_equal 1024, @malloc_buffer.capacity
+    end
+
+    def test_position
+      assert_equal 0, @mmap_buffer.position
+      assert_equal 0, @malloc_buffer.position
+    end
+
+    def test_to_s
+      assert_equal "\0" * @mmap_buffer.capacity, @mmap_buffer.to_s
+      assert_equal @malloc_buffer.capacity, @malloc_buffer.to_s.size
+    end
+
+    def test_write
+      data = "\xA\xB\xC"
+      @mmap_buffer.write data
+      assert_equal data, @mmap_buffer.to_s[0...data.size]
+    end
+
+    def test_execute
+      Evoasm::X64.encode(:mov_rm32_imm32, {reg0: :a, imm0: 7}, @mmap_buffer)
+      Evoasm::X64.encode(:ret, {}, @mmap_buffer)
+
+      #@mmap_buffer.__log__ :warn
+
+      assert_equal 7, @mmap_buffer.execute!
+    end
+
+  end
+end

data/test/unit/evoasm/capstone_test.rb

@@ -0,0 +1,18 @@
+require 'evoasm/test'
+require 'evoasm/capstone'
+
+class CapstoneTest < Minitest::Test
+  def test_disassemble_x64
+
+    asm = "\x55\x48\x8b\x05\xb8\x13\x00\x00"
+    inst1 = ['push', 'rbp']
+    inst2 = ['mov', 'rax, qword ptr [rip + 0x13b8]']
+
+    assert_equal [inst1, inst2],
+                 Evoasm::Capstone.disassemble_x64(asm)
+
+    assert_equal [[0x80, *inst1], [0x81, *inst2]],
+                 Evoasm::Capstone.disassemble_x64(asm, 0x80)
+
+  end
+end

data/test/unit/evoasm/domain_test.rb

@@ -0,0 +1,55 @@
+require 'evoasm/test'
+require 'evoasm/domain'
+require 'evoasm/prng'
+
+module Evoasm
+  class DomainTest < Minitest::Test
+
+    def setup
+      @prng = PRNG.new
+    end
+
+    def test_enumeration_domain
+      enumeration_domain = Evoasm::EnumerationDomain.new 1, 2, 3, 4
+      assert_equal [1, 2, 3, 4], enumeration_domain.values
+      assert_equal 4, enumeration_domain.length
+    end
+
+    def test_range_domain
+      range_domain = Evoasm::RangeDomain.new -10, 100
+      assert_equal -10, range_domain.min
+      assert_equal 100, range_domain.max
+
+      100.times do
+        assert_operator range_domain.rand(@prng), :>=, -10
+        assert_operator range_domain.rand(@prng), :<=, 100
+      end
+
+      range_domain = Evoasm::RangeDomain.new 10, 100_000
+      assert_equal 10, range_domain.min
+      assert_equal 100_000, range_domain.max
+    end
+
+    def test_type_domain
+      type_domain = Evoasm::TypeDomain.new :int8
+      assert_equal :int8, type_domain.type
+      assert_equal -2**7, type_domain.min
+      assert_equal 2**7 - 1, type_domain.max
+
+      type_domain = Evoasm::TypeDomain.new :int16
+      assert_equal :int16, type_domain.type
+      assert_equal -2**15, type_domain.min
+      assert_equal 2**15 - 1, type_domain.max
+
+      type_domain = Evoasm::TypeDomain.new :int32
+      assert_equal :int32, type_domain.type
+      assert_equal -2**31, type_domain.min
+      assert_equal 2**31 - 1, type_domain.max
+
+      type_domain = Evoasm::TypeDomain.new :int64
+      assert_equal :int64, type_domain.type
+      assert_equal -2**63, type_domain.min
+      assert_equal 2**63 - 1, type_domain.max
+    end
+  end
+end