external 0.1.0

data/test/check/benchmark_check.rb

@@ -0,0 +1,441 @@
+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

data/test/check/namespace_conflicts_check.rb

@@ -0,0 +1,23 @@
+module External
+  class Array
+  end
+end
+
+require 'test/unit'
+
+class NamespaceConfilctsCheck < Test::Unit::TestCase
+  include External
+  
+  # this is why it's problematic to use a naming scheme like:
+  #   External::Index
+  #   External::Array
+  #   External::Archive
+  #
+  # even if you alias to the top level, within External itself
+  # there is some ambiguity about whether you're using Array
+  # or External::Array
+  
+  def test_array_now_refers_to_external_array
+    assert_equal Array, External::Array
+  end
+end

data/test/check/pack_check.rb

@@ -0,0 +1,90 @@
+require 'test/unit'
+
+# a variety of tests that establish some basic facts/assumptions
+# that get leveraged in somewhere in the library
+class PackCheck < Test::Unit::TestCase
+  
+  # NOTE: upon pack:
+  # unsigned values throw an error if > MAX or < -MAX
+  # negative values are the same as positive values counting back from MAX
+  
+  LONG_MIN = -2147483648
+  LONG_MAX = 2147483647 
+  
+  ULONG_MIN = 0
+  ULONG_MAX = 4294967295
+  
+  LLONG_MIN = -9223372036854775808
+  LLONG_MAX = 9223372036854775807
+
+  ULLONG_MIN = 0
+  ULLONG_MAX = 18446744073709551615
+  
+  def test_negative_unsigned_values_count_back_from_max_in_pack_and_unpack
+    assert_equal [ULONG_MAX], [-1].pack('I').unpack('I')
+    assert_equal [ULONG_MAX], [-1].pack('L').unpack('L')
+    assert_equal [ULLONG_MAX], [-1].pack('Q').unpack('Q')
+  end
+
+  def test_signed_values_beyond_min_count_back_from_max_in_pack_and_unpack
+    assert_equal [LONG_MAX], [LONG_MIN-1].pack('i').unpack('i')
+    assert_equal [LONG_MAX], [LONG_MIN-1].pack('l').unpack('l')
+    assert_equal [LLONG_MAX], [LLONG_MIN-1].pack('q').unpack('q')
+  end
+  
+  def test_signed_values_beyond_max_count_up_from_min_in_pack_and_unpack
+    assert_equal [LONG_MIN], [LONG_MAX+1].pack('i').unpack('i')
+    assert_equal [LONG_MIN], [LONG_MAX+1].pack('l').unpack('l')
+    assert_equal [LLONG_MIN], [LLONG_MAX+1].pack('q').unpack('q')
+  end
+  
+  def test_numeric_ranges_for_pack_and_unpack
+    # I,L handle an unsigned long
+    ['I', 'L'].each do |format|
+      assert_equal [ULONG_MIN], [ULONG_MIN].pack(format).unpack(format)
+      assert_equal [ULONG_MAX], [ULONG_MAX].pack(format).unpack(format)
+      
+      #assert_equal [ULONG_MIN], [ULONG_MAX+1].pack(format).unpack(format)
+      assert_equal [ULONG_MAX], [ULONG_MIN-1].pack(format).unpack(format)
+      
+      assert_raise(RangeError) { [-(ULONG_MAX+1)].pack(format) }
+      assert_raise(RangeError) { [(ULONG_MAX+1)].pack(format) }
+    end
+    
+    # i,l handle an signed long
+    ['i', 'l'].each do |format|
+      assert_equal [LONG_MIN], [LONG_MIN].pack(format).unpack(format)
+      assert_equal [LONG_MAX], [LONG_MAX].pack(format).unpack(format)
+      
+      assert_equal [LONG_MIN], [LONG_MAX+1].pack(format).unpack(format)
+      assert_equal [LONG_MAX], [LONG_MIN-1].pack(format).unpack(format)
+      
+      assert_raise(RangeError) { [-2*(LONG_MAX+1)].pack(format) }
+      assert_raise(RangeError) { [2*(LONG_MAX+1)].pack(format) }
+    end
+    
+    # Q handles an unsigned long long
+    ['Q'].each do |format|
+      assert_equal [ULLONG_MIN], [ULLONG_MIN].pack(format).unpack(format)
+      assert_equal [ULLONG_MAX], [ULLONG_MAX].pack(format).unpack(format)
+      
+      #assert_equal [ULLONG_MIN], [ULLONG_MAX+1].pack(format).unpack(format)
+      assert_equal [ULLONG_MAX], [ULLONG_MIN-1].pack(format).unpack(format)
+      
+      assert_raise(RangeError) { [-(ULLONG_MAX+1)].pack(format) }
+      assert_raise(RangeError) { [(ULLONG_MAX+1)].pack(format) }
+    end
+    
+    # q handles an signed long long
+    ['q'].each do |format|
+      assert_equal [LLONG_MIN], [LLONG_MIN].pack(format).unpack(format)
+      assert_equal [LLONG_MAX], [LLONG_MAX].pack(format).unpack(format)
+      
+      assert_equal [LLONG_MIN], [LLONG_MAX+1].pack(format).unpack(format)
+      assert_equal [LLONG_MAX], [LLONG_MIN-1].pack(format).unpack(format)
+      
+      assert_raise(RangeError) { [-2*(LLONG_MAX+1)].pack(format) }
+      assert_raise(RangeError) { [2*(LLONG_MAX+1)].pack(format) }
+    end
+  end
+end