mkrf 0.1.0

data/test/sample_files/syck-0.55/tests/YTS.c.erb

@@ -0,0 +1,326 @@
+//
+// YTS.c
+//
+// $Author: why $
+// $Date: 2005/04/13 06:27:54 $
+//
+// Copyright (C) 2004 why the lucky stiff
+//
+// Well, this is the Yaml Testing Suite in the form of a plain C
+// API.  Basically, this is as good as C integration gets for Syck.
+// You've got to have a symbol table around.  From there, you can
+// query your data.
+//
+
+#include <string.h>
+#include "syck.h"
+#include "CuTest.h"
+
+/* YAML test node structures */
+#define T_STR 10
+#define T_SEQ 20
+#define T_MAP 30
+#define T_END 40
+#define ILEN  2
+
+struct test_node {
+    int type;
+    char *tag;
+    char *key;
+    struct test_node *value;
+};
+struct test_node end_node = { T_END };
+
+/*
+ * Assertion which compares a YAML document with an
+ * equivalent set of test_node structs.
+ */
+SYMID
+syck_copy_handler(p, n)
+    SyckParser *p;
+    SyckNode *n;
+{
+    int i = 0;
+    struct test_node *tn = S_ALLOC_N( struct test_node, 1 );
+
+    switch ( n->kind )
+    {
+        case syck_str_kind:
+            tn->type = T_STR;
+            tn->key = syck_strndup( n->data.str->ptr, n->data.str->len );
+            tn->value = 0;
+        break;
+
+        case syck_seq_kind:
+        {
+            struct test_node *val;
+            struct test_node *seq = S_ALLOC_N( struct test_node, n->data.list->idx + 1 );
+            tn->type = T_SEQ;
+            tn->key = 0;
+            for ( i = 0; i < n->data.list->idx; i++ )
+            {
+                SYMID oid = syck_seq_read( n, i );
+                syck_lookup_sym( p, oid, (char **)&val );
+                seq[i] = val[0];
+            }
+            seq[n->data.list->idx] = end_node;
+            tn->value = seq;
+        }
+        break;
+
+        case syck_map_kind:
+        {
+            struct test_node *val;
+            struct test_node *map = S_ALLOC_N( struct test_node, ( n->data.pairs->idx * 2 ) + 1 );
+            tn->type = T_MAP;
+            tn->key = 0;
+            for ( i = 0; i < n->data.pairs->idx; i++ )
+            {
+                SYMID oid = syck_map_read( n, map_key, i );
+                syck_lookup_sym( p, oid, (char **)&val );
+                map[i * 2] = val[0];
+
+                oid = syck_map_read( n, map_value, i );
+                syck_lookup_sym( p, oid, (char **)&val );
+                map[(i * 2) + 1] = val[0];
+            }
+            map[n->data.pairs->idx * 2] = end_node;
+            tn->value = map;
+        }
+        break;
+    }
+
+    tn->tag = 0;
+    if ( n->type_id != NULL ) {
+        tn->tag = syck_strndup( n->type_id, strlen( n->type_id ) );
+    }
+
+    return syck_add_sym( p, (char *) tn );
+}
+
+int
+syck_free_copies( char *key, struct test_node *tn, char *arg )
+{
+    if ( tn != NULL ) {
+        switch ( tn->type ) {
+            case T_STR:
+                S_FREE( tn->key );
+            break;
+
+            case T_SEQ:
+            case T_MAP:
+                S_FREE( tn->value );
+            break;
+        }
+        if ( tn->tag != NULL ) S_FREE( tn->tag );
+        S_FREE( tn );
+    }
+    tn = NULL;
+    return ST_CONTINUE;
+}
+
+void CuStreamCompareX( CuTest* tc, struct test_node *s1, struct test_node *s2 ) {
+    int i = 0;
+    while ( 1 ) {
+        CuAssertIntEquals( tc, s1[i].type, s2[i].type );
+        if ( s1[i].type == T_END ) return;
+        if ( s1[i].tag != 0 && s2[i].tag != 0 ) CuAssertStrEquals( tc, s1[i].tag, s2[i].tag );
+        switch ( s1[i].type ) {
+            case T_STR:
+                CuAssertStrEquals( tc, s1[i].key, s2[i].key );
+            break;
+            case T_SEQ:
+            case T_MAP:
+                CuStreamCompareX( tc, s1[i].value, s2[i].value );
+            break;
+        }
+        i++;
+    }
+}
+
+void CuStreamCompare( CuTest* tc, char *yaml, struct test_node *stream ) {
+    int doc_ct = 0;
+    struct test_node *ystream = S_ALLOC_N( struct test_node, doc_ct + 1 );
+    CuString *msg;
+
+    /* Set up parser */
+    SyckParser *parser = syck_new_parser();
+    syck_parser_str_auto( parser, yaml, NULL );
+    syck_parser_handler( parser, syck_copy_handler );
+    syck_parser_error_handler( parser, NULL );
+    syck_parser_implicit_typing( parser, 1 );
+    syck_parser_taguri_expansion( parser, 1 );
+
+    /* Parse all streams */
+    while ( 1 )
+    {
+        struct test_node *ydoc;
+        SYMID oid = syck_parse( parser );
+        if ( parser->eof == 1 ) break;
+
+        /* Add document to stream */
+        syck_lookup_sym( parser, oid, (char **)&ydoc );
+        ystream[doc_ct] = ydoc[0];
+        doc_ct++;
+        S_REALLOC_N( ystream, struct test_node, doc_ct + 1 );
+    }
+    ystream[doc_ct] = end_node;
+
+    /* Traverse the struct and the symbol table side-by-side */
+    /* DEBUG: y( stream, 0 ); y( ystream, 0 ); */
+    CuStreamCompareX( tc, stream, ystream );
+
+    /* Free the node tables and the parser */
+    S_FREE( ystream );
+    if ( parser->syms != NULL )
+        st_foreach( parser->syms, syck_free_copies, 0 );
+    syck_free_parser( parser );
+}
+
+/*
+ * Setup for testing N->Y->N.
+ */
+void 
+test_output_handler( emitter, str, len )
+    SyckEmitter *emitter;
+    char *str;
+    long len;
+{
+    CuString *dest = (CuString *)emitter->bonus;
+    CuStringAppendLen( dest, str, len );
+}
+
+SYMID
+build_symbol_table( SyckEmitter *emitter, struct test_node *node ) {
+    switch ( node->type ) {
+        case T_SEQ:
+        case T_MAP:
+        {
+            int i = 0;
+            while ( node->value[i].type != T_END ) {
+                SYMID id = build_symbol_table( emitter, &node->value[i] );
+                i++;
+            }        
+        }
+        return syck_emitter_mark_node( emitter, (st_data_t)node );
+
+        case T_STR:
+        return 0;
+    }
+}
+
+void
+test_emitter_handler( SyckEmitter *emitter, st_data_t data ) {
+    struct test_node *node = (struct test_node *)data;
+    switch ( node->type ) {
+        case T_STR:
+            syck_emit_scalar( emitter, node->tag, scalar_none, 0, 0, 0, node->key, strlen( node->key ) );
+        break;
+        case T_SEQ:
+        {
+            int i = 0;
+            syck_emit_seq( emitter, node->tag, seq_none );
+            while ( node->value[i].type != T_END ) {
+                syck_emit_item( emitter, (st_data_t)&node->value[i] );
+                i++;
+            }        
+            syck_emit_end( emitter );
+        }
+        break;
+        case T_MAP:
+        {
+            int i = 0;
+            syck_emit_map( emitter, node->tag, map_none );
+            while ( node->value[i].type != T_END ) {
+                syck_emit_item( emitter, (st_data_t)&node->value[i] );
+                i++;
+            }        
+            syck_emit_end( emitter );
+        }
+        break;
+    }
+}
+
+void CuRoundTrip( CuTest* tc, struct test_node *stream ) {
+    int i = 0;
+    CuString *cs = CuStringNew();
+    SyckEmitter *emitter = syck_new_emitter();
+
+    /* Calculate anchors and tags */
+    build_symbol_table( emitter, stream );
+
+    /* Build the stream */
+    syck_output_handler( emitter, test_output_handler );
+    syck_emitter_handler( emitter, test_emitter_handler );
+    emitter->bonus = cs;
+    while ( stream[i].type != T_END )
+    {
+        syck_emit( emitter, (st_data_t)&stream[i] );
+        syck_emitter_flush( emitter, 0 );
+        i++;
+    }
+
+    /* Reload the stream and compare */
+    /* printf( "-- output for %s --\n%s\n--- end of output --\n", tc->name, cs->buffer ); */
+    CuStreamCompare( tc, cs->buffer, stream );
+    CuStringFree( cs );
+
+    syck_free_emitter( emitter );
+}
+
+/*
+ * ACTUAL TESTS FOR THE YAML TESTING SUITE BEGIN HERE
+ *   (EVERYTHING PREVIOUS WAS SET UP FOR THE TESTS)
+ */
+
+% syck_tests.each do |yt|
+/*
+ * Example <%= yt['spec'] %>: <%= yt['test'] %>
+ */
+void
+<%= yt['func'] %>( CuTest *tc )
+{
+<%= yt['syck'] %>
+
+    CuStreamCompare( tc,
+
+        /* YAML document */ 
+<%= yt['yaml'].gsub( /\\/, '\\\\\\\\' ).gsub( '"', '\"' ).gsub( /^(.*)$/, '"\1\n"' ) %>
+        ,
+
+        /* C structure of validations */
+        stream
+    );
+
+    CuRoundTrip( tc, stream );
+}
+% end
+
+CuSuite *
+SyckGetSuite()
+{
+    CuSuite *suite = CuSuiteNew();
+% syck_tests.each do |yt|
+    SUITE_ADD_TEST( suite, <%= yt['func'] %> );
+% end
+    return suite;
+}
+
+int main(void)
+{
+	CuString *output = CuStringNew();
+	CuSuite* suite = SyckGetSuite();
+    int count;
+
+	CuSuiteRun(suite);
+	CuSuiteSummary(suite, output);
+	CuSuiteDetails(suite, output);
+
+	printf("%s\n", output->buffer);
+    count = suite->failCount;
+
+    CuStringFree( output );
+    CuSuiteFree( suite );
+
+    return count;
+}

data/test/sample_files/syck-0.55/tests/YTS.c.rb

@@ -0,0 +1,44 @@
+#
+# YTS.c.rb
+#
+# $Author: why $
+# $Date: 2005/01/02 04:33:40 $
+#
+# Copyright (C) 2004 why the lucky stiff
+#
+# This Ruby script generates the YTS suite for the
+# Syck base lib.  Basically, it searches ext/ruby/yts/ for
+# tests with a 'syck' entry.
+#
+# To regenerate things yourself:
+#
+#   ruby YTS.c.rb > YTS.c
+#
+# Oh and your Ruby must have YAML installed.
+#
+require 'erb'
+require 'yaml'
+
+# Find the Syck directory.
+yts_dir = "ext/ruby/yts/"
+syck_dir = ""
+while File.expand_path( syck_dir ) != "/"
+    break if File.directory?( syck_dir + yts_dir )
+    syck_dir << "../"
+end
+yts_dir = syck_dir + yts_dir
+abort "No YTS directory found" unless File.directory?( yts_dir )
+
+# Load the YTS 
+syck_tests = []
+YAML::load( File.open( yts_dir + "index.yml" ) ).each do |yst|
+    ct = 0
+	YAML.each_document( File.open( yts_dir + yst + ".yml" ) ) do |ydoc|
+        ydoc['group'] = yst
+        ydoc['func'] = "#{ ydoc['group'] }_#{ ct }"
+        syck_tests << ydoc if ydoc['syck']
+        ct += 1
+    end
+end
+
+puts ERB.new( File.read( syck_dir + "tests/YTS.c.erb" ), 0, "%<>" ).result

data/test/test_availability.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+class TestAvailability < Test::Unit::TestCase
+  def setup
+    @avail = Mkrf::Availability.new(:includes => File.join(File.dirname(__FILE__), 'fixtures'))
+  end
+  
+  def test_has_library_should_return_true_when_lib_already_loaded
+    @avail =  Mkrf::Availability.new(:loaded_libs => ['sample_library'])
+    assert @avail.has_library?('sample_library')
+  end
+
+  def test_has_library_should_fail_on_bogus_lib
+    assert !@avail.has_library?('bogus_library')
+  end
+  
+  def test_can_link
+    @avail.send(:with_headers, 'stdio.h') do
+      assert @avail.can_link?(@avail.send(:simple_reference, "printf"))
+    end
+  end
+  
+  def test_create_source
+    assert !File.exist?(Mkrf::Availability::TEMP_SOURCE_FILE)
+
+    @avail.send(:create_source, "puts 'Hello World!'")
+
+    assert File.exist?(Mkrf::Availability::TEMP_SOURCE_FILE)
+
+    source = File.open(Mkrf::Availability::TEMP_SOURCE_FILE).read
+    assert_equal "puts 'Hello World!'", source
+  ensure
+    FileUtils.rm_f Mkrf::Availability::TEMP_SOURCE_FILE
+  end
+  
+  def test_has_header_should_fail_on_bogus_header
+    assert !@avail.has_header?('some_fake_header.h')
+  end
+  
+  def test_has_header_should_work_with_basic_headers
+    assert @avail.has_header?('stdmkrf.h')
+  end
+  
+  def test_has_header_should_check_many_paths
+    assert !@avail.has_header?('header_down_a_directory.h')
+    assert @avail.has_header?('header_down_a_directory.h', File.join(File.dirname(__FILE__), 'fixtures', 'down_a_directory'))
+  end
+  
+  def test_include_header
+    assert @avail.has_header?('stdmkrf.h')
+    assert !@avail.headers.include?('stdmkrf.h')
+    @avail.include_header('stdmkrf.h')
+    assert @avail.headers.include?('stdmkrf.h')
+  end
+  
+  # This should really use a trivial lib compiled in fixtures..
+  def test_include_library
+    assert @avail.has_library?('z')
+    assert !@avail.loaded_libs.include?('z')
+    @avail.include_library('z')
+    assert @avail.loaded_libs.include?('z')
+  end
+  
+  def test_method_missing_should_go_down_chain_when_not_catching_stackable_attributes
+    assert_raises(NoMethodError) { @avail.not_a_stackable_attribute }
+    assert_raises(NoMethodError) { @avail.with_not_a_stackable_attribute }
+  end
+end

data/test/test_generator.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+class TestGenerator < Test::Unit::TestCase
+  SAMPLES_DIR = File.dirname(__FILE__) + '/sample_files'
+  
+  SAMPLE_LIBS = {
+    :libtrivial => '/libtrivial/libtrivial_so.bundle',
+    :syck => '/syck-0.55/ext/ruby/ext/syck/syck.bundle',
+    :libxml => '/libxml-ruby-0.3.8/ext/xml/libxml_so.bundle'
+  }
+  
+  # Set to true for full command line output
+  @@debug = false
+  
+  def setup
+    silence_command_line do
+      system('rake test:samples:clean')
+    end
+  end
+  
+  def test_that_trivial_lib_compiles
+    assert !File.exist?(SAMPLES_DIR + SAMPLE_LIBS[:libtrivial])
+    silence_command_line do 
+      system('rake test:samples:trivial')
+    end
+    assert File.exist?(SAMPLES_DIR + SAMPLE_LIBS[:libtrivial])
+  end
+  
+  def test_that_syck_compiles
+    assert !File.exist?(SAMPLES_DIR + SAMPLE_LIBS[:syck])
+    silence_command_line do 
+      system('rake test:samples:syck')
+    end
+    assert File.exist?(SAMPLES_DIR + SAMPLE_LIBS[:syck])
+  end
+  
+  def test_that_libxml_compiles
+    assert !File.exist?(SAMPLES_DIR + SAMPLE_LIBS[:libxml])
+    silence_command_line do 
+      system('rake test:samples:libxml')
+    end
+    assert File.exist?(SAMPLES_DIR + SAMPLE_LIBS[:libxml])
+  end
+  
+  private
+  
+  def silence_command_line
+    yield and return if @@debug
+    silence_stream(STDERR) do
+      silence_stream(STDOUT) do
+        yield
+      end
+    end
+  end
+  
+  # silence_stream taken from Rails ActiveSupport reporting.rb
+  
+  # Silences any stream for the duration of the block.
+  #
+  #   silence_stream(STDOUT) do
+  #     puts 'This will never be seen'
+  #   end
+  #
+  #   puts 'But this will'
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+  end
+  
+end