external 0.1.0 → 0.3.0

data/test/cached_ext_ind_test.rb

@@ -1,219 +0,0 @@
-require File.join(File.dirname(__FILE__), 'ext_ind_test.rb') 
-
-class CachedExtIndTest < ExtIndTest
-  class CachedExtInd < ExtInd
-    def initialize(io=nil, options={})
-      options = {
-        :cached => true
-      }.merge(options)
-      
-      super(io, options)
-    end
-  end
-  
-  def setup
-    # cls represents an array
-    @cls = CachedExtInd
-
-    @index = CachedExtInd.new
-    @index.cache.concat(framed_array)
-  end
-  
-  def teardown
-  end
-  
-  #
-  # setup tests
-  #
-  
-  def test_setup
-    assert_equal CachedExtInd, @cls
-    
-    assert_equal 0, index.pos
-    assert_equal 5, index.length
-    assert_equal 4, index.frame_size
-    assert index.cached?
-    assert_equal framed_array, index.cache
-  end
-  
-  
-  #
-  # initialize tests
-  #
-  
-  undef_method :test_index_initialized_to_single_int_format_by_default
-  
-  def test_cache_initialized_to_empty_array_in_cached_mode
-    index = @cls.new
-  
-    assert_equal 'I*', index.format
-    assert_equal 1, index.frame
-    assert_equal 4, index.frame_size
-    assert_equal [0], index.nil_value
-    assert index.cached?
-    assert_equal [], index.cache
-  end
-  
-  def test_cache_initialized_to_empty_array_in_cached_mode_regardless_of_format
-    index = @cls.new nil, :format => "IQS"
-
-    assert index.cached?
-    assert_equal [], index.cache
-  end
-  
-  #
-  # class read tests
-  #
-  
-  undef_method :test_read_returns_the_index_file_in_frame
-  
-  #
-  # class directive size tests
-  #
-  
-  undef_method :test_directive_size_returns_the_number_of_bytes_to_pack_a_directive
- 
-  #
-  # length test
-  #
-  
-  undef_method :test_length_returns_io_length_divided_by_frame_size
-  
-  def test_length_returns_cache_length
-    assert_equal index.cache.length, index.length
-    
-    index.cache.clear
-    assert_equal 0, index.length
-    
-    index.cache.concat([[1],[2],[3]])
-    assert_equal 3, index.length
-  end
-  
-  def test_length_is_separate_from_io_length
-    index.cache.clear
-    assert_equal 0, index.length
-    
-    index.io.length = 10
-    assert_equal 0, index.length
-  end
-  
-  #
-  # pos test
-  #
-  
-  undef_method :test_pos_returns_io_pos_divided_by_frame_size
-  
-  def test_pos_is_kept_separate_from_io_pos_in_cached_mode
-    assert_equal 0, index.io.pos
-    assert_equal 0, index.pos
-    
-    index.io.pos = 4
-    assert_equal 4, index.io.pos
-    assert_equal 0, index.pos
-  end
-  
-  #
-  # pos= test
-  #
-  
-  undef_method :test_pos_set_sets_io_pos_to_index_value_of_input_times_frame_size
-  
-  def test_pos_set_sets_pos_to_index_value_of_input
-    index.pos = 1
-    assert_equal 1, index.pos
-    
-    index.pos = -1
-    assert_equal 4, index.pos
-  end
-  
-  #
-  # readbytes test
-  #
-  
-  undef_method :test_readbytes_behavior_is_like_io_behavior
-  
-  #
-  # unframed_write tests
-  #
-  
-  undef_method :test_unframed_write_unframed_writes_packed_array_to_io_at_pos_and_adjusts_io_length
-  
-  def test_unframed_write_unframed_writes_packed_array_to_cache_in_frame_and_does_not_affect_io
-    index = @cls.new
-    index.unframed_write([1,2,3])
-    assert_equal 0, index.io.length
-    assert_equal 0, index.io.pos
-    
-    assert_equal [[1],[2],[3]], index.cache
-     
-    index.unframed_write([-2], 1)
-    assert_equal 0, index.io.length
-    assert_equal 0, index.io.pos
-
-    assert_equal [[1],[-2],[3]], index.cache
-  end
-  
-  def test_unframed_write_pads_with_nil_value_if_position_is_past_length
-    index = @cls.new nil, :nil_value => [8]
-    assert_equal 0, index.length
-    
-    index.unframed_write([1,2,3], 2)
-    assert_equal [[8],[8],[1],[2],[3]], index.cache
-  end
-  
-  def test_unframed_write_unframed_writes_nothing_with_empty_array
-    assert_equal framed_array, index.cache
-    
-    index.unframed_write([])
-    assert_equal framed_array, index.cache
-    
-    index.unframed_write([], 0)
-    assert_equal framed_array, index.cache
-  end
-  
-  #
-  # mixed formats test
-  #
-  
-  def test_read_handles_mixed_formats
-    index = @cls.new nil, :format => "IQS"
-    
-    index.cache << [1,2,3]
-    index.cache << [4,5,6]
-    index.cache << [7,8,9]
-    
-    assert_equal [[1,2,3],[4,5,6],[7,8,9]], index.read
-    
-    index.pos = 1
-    assert_equal [4,5,6], index.read(1)
-  end
-  
-  def test_unframed_write_handles_mixed_formats
-    index = @cls.new nil, :format => "IQS"
-    a = [1,2,3]
-    b = [4,5,6]
-    c = [7,8,9]
-    d = [-4,-5,-6]
-    
-    index.unframed_write([1,2,3,4,5,6,7,8,9])
-    assert_equal [a,b,c], index.cache
-
-    index.pos = 1
-    index.unframed_write([-4,-5,-6])
-    assert_equal [a,d,c], index.cache
-  end
-  
-  #
-  # numeric format range tests
-  #
-  
-  undef_method :test_read_and_unframed_write_handles_full_numeric_range_for_numeric_formats
-  undef_method :test_read_and_unframed_write_cycle_numerics_beyond_natural_range
-  undef_method :test_numerics_cycle_up_to_the_unsigned_max_in_either_sign
-
-  def test_unframed_write_does_NOT_check_formatting_of_input_in_cached_mode
-    index = @cls.new nil, :format => "S"
-    assert_raise(RangeError) { [ExtIndTest::ULLONG_MAX].pack("S") }
-    assert_nothing_raised { index.unframed_write([ExtIndTest::ULLONG_MAX]) }
-  end
-end

data/test/check/benchmark_check.rb

@@ -1,441 +0,0 @@
-require 'test/unit'
-require 'benchmark'
-require 'tap/test/subset_methods'
-
-ENV['benchmark'] = 'true'
-
-class BenchmarkCheck < Test::Unit::TestCase
-  include Tap::Test::SubsetMethods
-  include Benchmark
-  
-  if match_platform?('darwin')
-    require 'inline'
-    
-    inline do |builder|
-      builder.c %Q{
-      int read_in_chunk(VALUE str, int n, int times) {
-        char *filepath = RSTRING(str)->ptr;
-        FILE *fp = fopen(filepath, "r");
-        char input[(n*times)];
-        int len = (n*times)+1;  // ADD ONE to the read length because a null is appended as well
-
-        if (fp != NULL)
-        {
-          fgets(input, len, fp);
-          //printf(input);
-          fclose(fp);
-          return 1;
-        }
-        else
-          return 0;
-      }}
-    end
-    
-    inline do |builder|
-      builder.c %Q{
-      int read_in_pieces(VALUE str, int n, int times) {
-        char *filepath = RSTRING(str)->ptr;
-        FILE *fp = fopen(filepath, "r");
-        char input[n];
-        int len = n+1;  // ADD ONE to the read length because a null is appended as well
-        int i = 0;
-
-        if (fp != NULL)
-        {
-          while(i < times)
-          {
-            fgets(input, len, fp);
-            //printf(input);
-            ++i;
-          }
-          fclose(fp);
-          return 1;
-        }
-        else
-          return 0;
-      }}
-    end
-      
-    inline do |builder|
-      builder.c %Q{
-      int read_in_one_block(VALUE str, int len, int times) {
-        char *filepath = RSTRING(str)->ptr;
-        FILE *fp = fopen(filepath, "r");
-        char input[len*times];
-        int n_read;
-        
-        if (fp != NULL)
-        {
-          n_read = fread(input, len, times, fp);
-          input[n_read*len] = NULL;
-          //printf(input);
-          fclose(fp);
-          return 1;
-        }
-        else
-          return 0;
-      }}
-    end
-    
-    inline do |builder|
-      builder.c %Q{
-      int read_in_blocks(VALUE str, int len, int times) {
-        char *filepath = RSTRING(str)->ptr;
-        FILE *fp = fopen(filepath, "r");
-        char input[len];
-        int n_read;
-        int i = 0;
-        
-        if (fp != NULL)
-        {
-          while(i < times)
-          {
-            fread(input, len, 1, fp);
-            input[len] = NULL;
-            //printf(input);
-            ++i;
-          }
-          
-          fclose(fp);
-          return 1;
-        }
-        else
-          return 0;
-      }}
-    end
-  end
-  
-  def test_read_in_chunk_vs_read_in_pieces
-    platform_test("darwin") do
-      begin 
-        filepath = File.expand_path("background_test.txt")
-        File.open(filepath, "w") do |file|
-           10000.times do
-             file << "0123456789"
-           end
-        end
-        assert_equal 10000*10, File.size(filepath)
-        
-        benchmark_test(20) do |x|
-          x.report("1kx read in chunk") { 1000.times { assert read_in_chunk(filepath, 10, 10000) }}
-          x.report("1kx read in pieces") { 1000.times { assert read_in_pieces(filepath, 10, 10000) }}
-          x.report("1kx read in one block") { 1000.times { assert read_in_one_block(filepath, 10, 10000) }}
-          x.report("1kx read in blocks") { 1000.times { assert read_in_blocks(filepath, 10, 10000) }}
-          x.report("1kx File.read") { 1000.times { File.read(filepath) }}
-        end
-        
-      ensure
-        FileUtils.rm(filepath) if File.exists?(filepath)
-      end
-    end
-  end
-  
-  if match_platform?('darwin')
-    require 'inline'
- 
-    inline do |builder|
-      builder.c %Q{
-
-      VALUE unpack_to_array(VALUE str, int frame, int size, int times) {
-        char *filepath = RSTRING(str)->ptr;
-        FILE *fp = fopen(filepath, "r");
-        char input[frame*size*times];
-        char *p = input;
-        int i, j;
-        VALUE results, arr;
-
-        if (fp == NULL)
-          rb_raise(rb_eArgError, "couldn't open file");
-
-        times = fread(input, frame*size, times, fp);
-        results = rb_ary_new();
-
-        // convert to Fixnums
-        i = 0;
-        while(i < times)
-        {
-          j = 0;
-          arr = rb_ary_new();
-          while(j < frame)
-          {
-            // no need to copy the data at *p,
-            // apparently the conversion can 
-            // happen directly from the pointer
-      		  rb_ary_push(arr, UINT2NUM(*p));
-      		  p += size;
-            ++j;
-    		  }
-
-    		  rb_ary_push(results, arr);
-    		  ++i;
-        }
-
-        fclose(fp);
-        return results;
-      }}
-    end
-  end
-  
-  require 'enumerator'
-  
-  def test_read_into_arrays
-    platform_test("darwin") do
-      begin 
-        filepath = File.expand_path("background_test.txt")
-        
-        times = 5000
-        frame = 5
-        size = 4
-        format = "I*"
-        
-        array = Array.new(times) { (1..frame).to_a }
-        File.open(filepath, "w") do |file|
-          file << array.flatten.pack(format)
-        end
-        assert_equal 10000*10, File.size(filepath)
-        assert_equal array, unpack_to_array(filepath, frame, size, times)
-        
-        benchmark_test(20) do |x|
-          x.report("100x unpack to array") { 100.times { unpack_to_array(filepath, frame, size, times) }}
-          
-          results = []
-          File.read(filepath).unpack(format).each_slice(frame) do |arr|
-            results << arr
-          end
-          assert_equal array, results
-          x.report("100x File.read.unpack") do 
-            100.times do
-              results = []
-              File.read(filepath).unpack(format).each_slice(frame) do |arr|
-                results << arr
-              end
-            end
-          end
-        end
-
-      ensure
-        FileUtils.rm(filepath) if File.exists?(filepath)
-      end  
-    end
-  end
-  
-  if match_platform?('darwin')
-    require 'inline'
- 
-    inline do |builder|
-      builder.c %Q{
-
-      VALUE unpack_str(VALUE str, int frame, int size, int times) {
-        char *p = RSTRING(str)->ptr;
-        int i, j;
-        VALUE results, arr;
-        char directive = 'I';
-        results = rb_ary_new();
-
-        i = 0;
-        while(i < times)
-        {
-          j = 0;
-          arr = rb_ary_new();
-          while(j < frame)
-          {
-            switch(directive)
-            {
-              case 'I':
-                {// no need to copy the data at *p,
-                // apparently the conversion can 
-                // happen directly from the pointer
-          		  rb_ary_push(arr, UINT2NUM(*p));
-          		  p += size;
-                ++j;}
-                break;
-            }
-    		  }
-
-    		  rb_ary_push(results, arr);
-    		  ++i;
-        }
-
-        return results;
-      }}
-    end
-  end
-  
-  require 'enumerator'
-  
-  def test_unpack_speed
-    platform_test("darwin") do
-      begin 
-        filepath = File.expand_path("background_test.txt")
-        
-        times = 5000
-        frame = 5
-        size = 4
-        format = "I*"
-        
-        array = Array.new(times) { (1..frame).to_a }
-        File.open(filepath, "w") do |file|
-          file << array.flatten.pack(format)
-        end
-        assert_equal 10000*10, File.size(filepath)
-        
-        str = File.read(filepath)
-        assert_equal array, unpack_str(str, frame, size, times)
-        
-        benchmark_test(20) do |x|
-          x.report("100x unpack") { 100.times { unpack_str(str, frame, size, times) }}
-          
-          results = []
-          File.read(filepath).unpack(format).each_slice(frame) do |arr|
-            results << arr
-          end
-          assert_equal array, results
-          x.report("100x str.unpack") do 
-            100.times do
-              results = []
-              str.unpack(format).each_slice(frame) do |arr|
-                results << arr
-              end
-            end
-          end
-        end
-
-      ensure
-        FileUtils.rm(filepath) if File.exists?(filepath)
-      end  
-    end
-  end
-  
-  if match_platform?('darwin')
-    require 'inline'
- 
-    inline do |builder|
-      builder.c %Q{
-
-      int work_with_values() {
-      	int a = NUM2INT(rb_iv_get(self, "@a"));
-      	int b = NUM2INT(rb_iv_get(self, "@b"));
-      	
-        return a + b;
-      }}
-    end
-  end
-  
-  attr_accessor :a, :b
-  
-  def test_work_with_values
-    platform_test("darwin") do
-      @a = 10
-      @b = 2
-        
-      assert_equal 12, work_with_values
-    end
-  end
-  
-  if match_platform?('darwin')
-    require 'inline'
-    
-    module FileExt
-      inline do |builder|
-        builder.include "<rubyio.h>"
-        builder.c %Q{
-
-        int read_from_file(int n) {
-        	FILE *fp = RFILE(self)->fptr->f;
-        	
-          char input[n];
-          int len = n+1;  // ADD ONE to the read length because a null is appended as well
-
-          if (fp != NULL)
-          {
-            fgets(input, len, fp);
-            //printf(input);
-            fclose(fp);
-            return 1;
-          }
-          else
-            return 0;
-        }}
-      end
-    end
-  end
-  
-  def test_get_file_pointer
-    platform_test("darwin") do
-      begin 
-        filepath = File.expand_path("background_test.txt")
-        File.open(filepath, 'w+') do |file|
-          file.extend FileExt
-          file << "hello world"
-          file.pos = 0
-          assert file.read_from_file(5)
-        end
-      ensure
-        FileUtils.rm(filepath) if File.exists?(filepath)
-      end
-    end
-  end
-  
-  if match_platform?('darwin')
-    require 'inline'
-    
-    inline do |builder|
-      builder.include "<rubyio.h>"
-      builder.c %Q{
-      int read_from_file(int len, int times) {
-        FILE *fp = RFILE(rb_iv_get(self, "@file"))->fptr->f;  
-        char input[len*times];
-        
-        if (fp == NULL)
-          return 0;
-          
-        fread(input, len, times, fp);
-        input[len*times] = NULL;
-        // printf(input);
- 
-        return 1;
-      }}
-    end
-  end
-  
-  attr_reader :file
-  
-  def test_read_from_open_file
-    platform_test("darwin") do
-      begin 
-        filepath = File.expand_path("background_test.txt")
-        File.open(filepath, "w") do |file|
-           10000.times do
-             file << "0123456789"
-           end
-        end
-        assert_equal 10000*10, File.size(filepath)
-        
-        
-        File.open(filepath) do |file|
-          @file = file
-          
-          file.pos = 0
-          assert read_from_file(10, 2)
-          
-          benchmark_test(20) do |x|
-            x.report("1kx read from file") { 1000.times { file.pos = 0; read_from_file(10, 10000) }}
-            x.report("1kx file.read") { 1000.times { file.pos = 0; file.read }}
-          end
-        
-        end
-      ensure
-        FileUtils.rm(filepath) if File.exists?(filepath)
-      end
-    end
-  end
-  
-  def test_array_methods
-    benchmark_test(20) do |x|
-      a = []
-      x.report("1M <<") { (1*1000000).times { a << 1 } }
-      a.clear
-      x.report("1M []") { (1*1000000).times { a[1] = 1 } }
-    end
-  end
-end