autoc 1.4 → 2.0.0

data/lib/autoc/scaffold/test_value_hash_set.rb

@@ -0,0 +1,60 @@
+require 'autoc/hash_set'
+
+type_test(AutoC::HashSet, :ValueHashSet, Value) do
+
+  ###
+
+  setup %{
+    #{self} t;
+  }
+
+  cleanup %{
+    #{destroy}(&t);
+  }
+
+  test :create_default, %{
+    #{default_create}(&t);
+    TEST_EQUAL( #{size}(&t), 0 );
+  }
+
+  test :create_custom, %{
+    #{create_capacity}(&t, 1024);
+    TEST_EQUAL( #{size}(&t), 0 );
+  }
+
+  ###
+
+  setup %{
+    #{self} t;
+    #{default_create}(&t);
+  }
+
+  cleanup %{
+    #{destroy}(&t);
+  }
+
+  test :put, %{
+    #{element} e;
+    #{element.create}(&e);
+    TEST_TRUE( #{put}(&t, e) );
+    TEST_EQUAL( #{size}(&t), 1 );
+    TEST_FALSE( #{put}(&t, e) );
+    TEST_EQUAL( #{size}(&t), 1 );
+    #{element.destroy}(&e);
+  }
+
+  test :push, %{
+    #{element} e1, e2;
+    #{element.create}(&e1);
+    #{element.set}(&e2, -1);
+    TEST_FALSE( #{push}(&t, e1) );
+    TEST_EQUAL( #{size}(&t), 1 );
+    TEST_FALSE( #{push}(&t, e2) );
+    TEST_EQUAL( #{size}(&t), 2 );
+    TEST_TRUE( #{push}(&t, e1) );
+    TEST_EQUAL( #{size}(&t), 2 );
+    #{element.destroy}(&e1);
+    #{element.destroy}(&e2);
+  }
+  
+end

data/lib/autoc/scaffold/test_value_vector.rb

@@ -0,0 +1,146 @@
+require 'autoc/vector'
+
+type_test(AutoC::Vector, :ValueVector, Value) do
+
+  #
+
+  setup %{ #{self} t; }
+  cleanup %{ #{destroy}(&t); }
+
+  test :create_smallest, %{
+    #{create_size}(&t, 1);
+    TEST_EQUAL( #{size}(&t), 1 );
+  }
+
+  test :create_large, %{
+    #{create_size}(&t, 1024);
+    TEST_EQUAL( #{size}(&t), 1024 );
+  }
+
+  #
+
+  setup %{
+    #{self} t;
+    #{element} e;
+    int i, c = 3;
+    #{create_size}(&t, c);
+    for(i = 0; i < c; ++i) {
+      #{element.custom_create}(&e, i);
+      #{set}(&t, i, e);
+      #{element.destroy}(&e);
+    }
+  }
+  cleanup %{ #{destroy}(&t); }
+
+  test :get, %{
+    #{element} e2;
+    #{element.custom_create}(&e, 2);
+    e2 = #{get}(&t, 2);
+    TEST_TRUE( #{element.equal}(e, e2) );
+    #{element.destroy}(&e);
+    #{element.destroy}(&e2);
+  }
+
+  test :set, %{
+    #{element} e2;
+    #{element.custom_create}(&e, -1);
+    #{set}(&t, 2, e);
+    e2 = #{get}(&t, 2);
+    TEST_TRUE( #{element.equal}(e, e2) );
+    #{element.destroy}(&e);
+    #{element.destroy}(&e2);
+  }
+
+  test :check_position, %{
+    TEST_TRUE( #{check}(&t, 0) );
+    TEST_TRUE( #{check}(&t, 2) );
+    TEST_FALSE( #{check}(&t, 3) );
+  }
+
+  test :iterate_forward, %{
+    i = 0;
+    #{range} r;
+    for(#{range.create}(&r, &t); !#{range.empty}(&r); #{range.pop_front}(&r)) {
+      e = #{range.take_front}(&r);
+      TEST_EQUAL( #{element.get}(e), i++ );
+      #{element.destroy}(&e);
+    }
+  }
+
+  test :iterate_backward, %{
+    i = c-1;
+    #{range} r;
+    for(#{range.create}(&r, &t); !#{range.empty}(&r); #{range.pop_back}(&r)) {
+      e = #{range.take_back}(&r);
+      TEST_EQUAL( #{element.get}(e), i-- );
+      #{element.destroy}(&e);
+    }
+  }
+
+  #
+
+  setup %{
+    #{self} t1, t2;
+    #{element} e;
+    int i, c = 3;
+    #{create_size}(&t1, c);
+    #{create_size}(&t2, c);
+    TEST_TRUE( #{equal}(&t1, &t2) );
+    for(i = 0; i < c; ++i) {
+      #{element.custom_create}(&e, i);
+      #{set}(&t1, i, e);
+      #{set}(&t2, i, e);
+      #{element.destroy}(&e);
+    }
+    TEST_TRUE( #{equal}(&t1, &t2) );
+  }
+  cleanup %{
+    #{destroy}(&t1);
+    #{destroy}(&t2);
+  }
+  
+  test :size, %{
+    TEST_EQUAL( #{size}(&t1), 3 );
+    TEST_EQUAL( #{size}(&t1), #{size}(&t2) );
+    #{resize}(&t2, 1);
+    TEST_EQUAL( #{size}(&t2), 1 );
+    TEST_NOT_EQUAL( #{size}(&t1), #{size}(&t2) );
+  }
+
+  test :equal, %{
+    #{element.custom_create}(&e, -1);
+    #{set}(&t1, 0, e);
+    #{element.destroy}(&e);
+    TEST_FALSE( #{equal}(&t1, &t2) );
+  }
+
+  test :resize_shrink, %{
+    #{resize}(&t2, 2);
+    TEST_EQUAL( #{size}(&t2), 2 );
+    TEST_FALSE( #{equal}(&t1, &t2) );
+  }
+
+  test :resize_expand, %{
+    #{resize}(&t2, 4);
+    TEST_EQUAL( #{size}(&t2), 4 );
+    TEST_FALSE( #{equal}(&t1, &t2) );
+    e = #{get}(&t2, 3);
+    TEST_EQUAL( #{element.get}(e), 0 );
+    TEST_NOT_EQUAL( #{element.get}(e), 1 );
+    #{element.destroy}(&e);
+  }
+
+  test :sort, %{
+    #{sort}(&t2, +1);
+    TEST_TRUE( #{equal}(&t1, &t2) );
+    e = #{get}(&t2, 0);
+    TEST_EQUAL( #{element.get}(e), 0 );
+    #{element.destroy}(&e);
+    #{sort}(&t2, -1);
+    TEST_FALSE( #{equal}(&t1, &t2) );
+    e = #{get}(&t2, 0);
+    TEST_EQUAL( #{element.get}(e), 2 );
+    #{element.destroy}(&e);
+  }
+
+end

data/{test/test.rb → lib/autoc/scaffold/tests.rb}

@@ -1,158 +1,179 @@
-=begin
-
-This is the AutoC automatic unit test generator.
-Usage instruction:
-
-1. Generate get test's source code (test_auto.c and test_auto.h):
-> ruby -I . -I ../lib test.rb
-
-2. Compile the generated code:
-> cc test_auto.c
-  
-3. Run the tests:
-> ./a.out
-
-The code is intended to finish succesfully,
-the process' exit code is zero when all tests are passed
-ano non-zero if there were failed tests.
-
-The compile-time warnings are possible and may be ignored.
-
-The compiled code should also pass the memory leakage tests
-(with Valgrind, Dr.Memory etc.)
-
-=end
-
-require "autoc"
-
-Prologue = Class.new(AutoC::Code) do
-  def write_defs(stream)
-    stream << %~
-      #include <stdio.h>
-      struct {
-        int total, processed, failed;
-      } tests;
-      int failure;
-      typedef void (*test_func)(void);
-      void run_test(const char* name, test_func func) {
-        fprintf(stdout, "|   %s\\n", name);
-        fflush(stdout);
-        failure = 0;
-        func();
-        if(failure) tests.failed++;
-        tests.processed++;
-      }
-      void print_condition_failure(const char* message, const char* condition, const char* file, int line) {
-        fprintf(stderr, "*** %s : %s (%s:%d)\\n", condition, message, file, line);
-        fflush(stderr);
-        failure = 1;
-      }
-      void print_equality_failure(const char* message, const char* x, const char* y, const char* file, int line) {
-        fprintf(stderr, "*** %s == %s : %s (%s:%d)\\n", x, y, message, file, line);
-        fflush(stderr);
-        failure = 1;
-      }
-      void print_summary(void) {
-        if(tests.failed)
-          fprintf(stdout, "*** Failed %d of %d tests\\n", tests.failed, tests.processed);
-        else
-          fprintf(stdout, "+++ All %d tests passed successfully\\n", tests.processed);
-        fflush(stdout);
-      }
-      #define TEST_MESSAGE(s) fprintf(stderr, "*** %s\\n", s); fflush(stderr);
-      #define TEST_ASSERT(x) if(x) {} else print_condition_failure("evaluated to FALSE", #x, __FILE__, __LINE__) 
-      #define TEST_TRUE(x) if(x) {} else print_condition_failure("expected TRUE but got FALSE", #x, __FILE__, __LINE__) 
-      #define TEST_FALSE(x) if(x) print_condition_failure("expected FALSE but got TRUE", #x, __FILE__, __LINE__)
-      #define TEST_NULL(x) if((x) == NULL) {} else print_condition_failure("expected NULL", #x, __FILE__, __LINE__) 
-      #define TEST_NOT_NULL(x) if((x) == NULL) print_condition_failure("expected not NULL", #x, __FILE__, __LINE__)
-      #define TEST_EQUAL(x, y) if((x) == (y)) {} else print_equality_failure("expected equality", #x, #y, __FILE__, __LINE__)
-      #define TEST_NOT_EQUAL(x, y) if((x) == (y)) print_equality_failure("expected non-equality", #x, #y, __FILE__, __LINE__)
-      #define TEST_EQUAL_CHARS(x, y) if(strcmp(x, y) == 0) {} else print_equality_failure("expected strings equality", #x, #y, __FILE__, __LINE__)
-      #define TEST_NOT_EQUAL_CHARS(x, y) if(strcmp(x, y) == 0) print_equality_failure("expected strings non-equality", #x, #y, __FILE__, __LINE__)
-    ~
-  end
-end.new
-
-
-Epilogue = Class.new(AutoC::Code) do
-  def priority; AutoC::Priority::MIN end
-  def write_defs(stream)
-    total = 0
-    $tests.each {|t| total += t.tests.size}
-    stream << %~int main(int argc, char** argv) {~
-    stream << %~
-      tests.total = #{total};
-      tests.processed = tests.failed = 0;
-    ~
-    $tests.each {|t| t.write_test_calls(stream)}
-    stream << %~print_summary();~
-    stream << %~return tests.failed > 0;}~
-  end
-end.new
-
-
-$tests = []
-
-
-def type_test(cls, *opts, &code)
-  t = Class.new(cls) do
-    def entities; super << Prologue end
-    attr_reader :tests
-    def initialize(*args)
-      super
-      @tests = []
-      @test_names = []
-    end
-    def setup(code = nil)
-      @setup_code = code
-    end
-    def cleanup(code = nil)
-      @cleanup_code = code
-    end
-    def test(name, code)
-      s = name.to_s
-      @test_names << [name, func_name = eval("test#{s[0,1].upcase}#{s[1..-1]}")]
-      @tests << %~
-        void #{func_name}(void) {
-          #{@setup_code}
-          #{code}
-          #{@cleanup_code}
-        }
-      ~
-    end
-    def write_defs(stream)
-      super
-      @tests.each {|f| stream << f}
-      stream << %~void #{runTests}(void) {~
-        stream << %~
-          fprintf(stdout, "* %s\\n", "#{type}");
-          fflush(stdout);
-        ~
-        @test_names.each do |name, func_name|
-          stream << %~
-            run_test("#{name}", #{func_name});
-          ~
-        end
-      stream << %~
-        fputs("\\n", stdout); fflush(stdout);}
-      ~
-    end
-    def write_test_calls(stream)
-      stream << %$
-        #{runTests}();
-      $
-    end
-  end.new(*opts)
-  $tests << t
-  t.instance_eval(&code)
-end
-
-
-Dir["**/test_*.rb"].each {|t| load t}
-  
-  
-AutoC::Module.generate!(:Test) do |c|
-  c << Prologue
-  $tests.each {|t| c << t}
-  c << Epilogue
-end
+=begin
+
+This is the AutoC automatic unit test generator.
+Usage instruction:
+
+1. Generate get test's source code (test_auto.c and test_auto.h):
+> ruby -I . -I ../lib tests.rb
+
+2. Compile the generated code:
+> cc test_auto.c
+  
+3. Run the tests:
+> ./a.out
+
+The code is intended to finish succesfully,
+the process' exit code is zero when all tests are passed
+ano non-zero if there were failed tests.
+
+The compile-time warnings are possible and may be ignored.
+
+The compiled code should also pass the memory leakage tests
+(with Valgrind, Dr.Memory etc.)
+
+=end
+
+require 'autoc/module'
+
+def type_test(cls, *opts, **kws, &code)
+  t = Class.new(cls) do
+    attr_reader :tests
+    def initialize(*args, **kws)
+      super
+      @tests = []
+      @test_names = []
+      dependencies << $common
+    end
+    def setup(code = nil)
+      @setup_code = code
+    end
+    def cleanup(code = nil)
+      @cleanup_code = code
+    end
+    def test(name, code)
+      s = name.to_s
+      @test_names << [name, func_name = identifier("test_#{name}")]
+      @tests << %{
+        void #{func_name}(void) {
+          #{@setup_code}
+          #{code}
+          #{@cleanup_code}
+        } /* #{func_name} */ 
+      }
+    end
+    def render_forward_declarations(stream)
+      super
+      stream << "void #{run_tests}(void);"
+    end
+    def render_implementation(stream)
+      super
+      @tests.each { |f| stream << f }
+      stream << "void #{run_tests}(void) {"
+      stream << %{
+        fprintf(stdout, "* %s\\n", "#{type}");
+        fflush(stdout);
+      }
+      @test_names.each { |name, func_name| stream << %$run_test("#{name}", #{func_name});$ }
+      stream << %$fputs("\\n", stdout); fflush(stdout);}$
+    end
+    def write_test_calls(stream)
+      stream << "#{run_tests}();"
+    end
+  end.new(*opts, **kws)
+  $tests << t
+  t.instance_eval(&code)
+  t
+end
+
+$common = Class.new do
+
+  include AutoC::Entity
+
+  def render_forward_declarations(stream)
+    super
+    stream << %{
+      #include <stdio.h>
+      typedef void (*test_func)(void);
+      void run_test(const char* name, test_func func);
+      void print_condition_failure(const char* message, const char* condition, const char* file, int line);
+      void print_equality_failure(const char* message, const char* x, const char* y, const char* file, int line);
+      void print_summary(void);
+      #define TEST_MESSAGE(s) fprintf(stderr, "*** %s\\n", s); fflush(stderr);
+      #define TEST_ASSERT(x) if(x) {} else print_condition_failure("evaluated to FALSE", #x, __FILE__, __LINE__)
+      #define TEST_TRUE(x) if(x) {} else print_condition_failure("expected TRUE but got FALSE", #x, __FILE__, __LINE__)
+      #define TEST_FALSE(x) if(x) print_condition_failure("expected FALSE but got TRUE", #x, __FILE__, __LINE__)
+      #define TEST_NULL(x) if((x) == NULL) {} else print_condition_failure("expected NULL", #x, __FILE__, __LINE__)
+      #define TEST_NOT_NULL(x) if((x) == NULL) print_condition_failure("expected not NULL", #x, __FILE__, __LINE__)
+      #define TEST_EQUAL(x, y) if((x) == (y)) {} else print_equality_failure("expected equality", #x, #y, __FILE__, __LINE__)
+      #define TEST_NOT_EQUAL(x, y) if((x) == (y)) print_equality_failure("expected non-equality", #x, #y, __FILE__, __LINE__)
+      #define TEST_EQUAL_CHARS(x, y) if(strcmp(x, y) == 0) {} else print_equality_failure("expected strings equality", #x, #y, __FILE__, __LINE__)
+      #define TEST_NOT_EQUAL_CHARS(x, y) if(strcmp(x, y) == 0) print_equality_failure("expected strings non-equality", #x, #y, __FILE__, __LINE__)
+    }
+  end
+end.new
+
+$suite = Class.new do
+
+  include AutoC::Entity
+
+  def initialize = dependencies << $common
+
+  def render_implementation(stream)
+    super
+    stream << %{
+      #include <stdio.h>
+      struct {
+        int total, processed, failed;
+      } tests;
+      int failure;
+      void run_test(const char* name, test_func func) {
+        fprintf(stdout, "|   %s\\n", name);
+        fflush(stdout);
+        failure = 0;
+        func();
+        if(failure) tests.failed++;
+        tests.processed++;
+      }
+      void print_condition_failure(const char* message, const char* condition, const char* file, int line) {
+        fprintf(stderr, "*** %s : %s (%s:%d)\\n", condition, message, file, line);
+        fflush(stderr);
+        failure = 1;
+      }
+      void print_equality_failure(const char* message, const char* x, const char* y, const char* file, int line) {
+        fprintf(stderr, "*** %s == %s : %s (%s:%d)\\n", x, y, message, file, line);
+        fflush(stderr);
+        failure = 1;
+      }
+      void print_summary(void) {
+        if(tests.failed)
+          fprintf(stdout, "*** Failed %d of %d tests\\n", tests.failed, tests.processed);
+        else
+          fprintf(stdout, "+++ All %d tests passed successfully\\n", tests.processed);
+        fflush(stdout);
+      }
+    }
+    total = 0
+    $tests.each { |t| total += t.tests.size }
+    stream << "int main(int argc, char** argv) {"
+    stream << %{
+      tests.total = #{total};
+      tests.processed = tests.failed = 0;
+    }
+    $tests.each { |t| t.write_test_calls(stream) }
+    stream << "print_summary();"
+    stream << "return tests.failed > 0;}"
+  end
+
+end.new
+
+$tests = []
+
+require 'autoc/composite'
+
+#AutoC::Composite.decorator = AutoC::Composite::SNAKE_CASE_DECORATOR
+
+require_relative 'generic_value'
+
+Value = GenericValue.new(:Value)
+
+Dir[File.join(File.dirname(__FILE__), 'test_*.rb')].each { |t| require t }
+
+require 'autoc/cmake'
+
+x = AutoC::Module.render(:tests) do |m|
+  m << $suite
+  m.source_threshold = 100*1024 # Split module code into a set of TUs with ~100 Kb in size
+  $tests.each { |t| $suite.dependencies << t }
+end
+
+AutoC::CMake.render(x)

data/lib/autoc/scaffold.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# These methods are meant to be used by the one-liners: ruby -r autoc/scaffold -e tests
+
+# Generate generated interface reference header to processable with Doxygen
+def docs = require_relative 'scaffold/docs'
+
+# Generated test suite
+def tests = require_relative 'scaffold/tests'
+
+# Generate skeleton project
+def project = require_relative 'scaffold/project'

data/lib/autoc/sequential.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+
+module AutoC
+
+
+  # Method implementations for types which maintain predictable element order (vector, list, queue etc.)
+  module Sequential
+
+  private
+
+    def configure
+      super
+      contains.configure do
+        dependencies << find_first
+        inline_code %{
+          return #{find_first.(*parameters)} != NULL;
+        }
+      end
+      find_first.configure do
+        code %{
+          #{range} r;
+          assert(target);
+          for(r = #{range.new.(target)}; !#{range.empty.(:r)}; #{range.pop_front.(:r)}) {
+            #{element.const_lvalue} e = #{range.view_front.(:r)};
+            if(#{element.equal.('*e', value)}) return e;
+          }
+          return NULL;
+        }
+      end
+      equal.configure do
+        code %{
+          assert(left);
+          assert(right);
+          if(#{size.(left)} == #{size.(right)}) {
+            #{range} lr, rr;
+            for(
+              lr = #{range.new.(left)}, rr = #{range.new.(right)};
+              !#{range.empty.(:lr)} && !#{range.empty.(:rr)};
+              #{range.pop_front.(:lr)}, #{range.pop_front.(:rr)}
+            ) {
+              #{element.const_lvalue} le = #{range.view_front.(:lr)};
+              #{element.const_lvalue} re = #{range.view_front.(:rr)};
+              if(!(#{element.equal.('*le', '*re')})) return 0;
+            }
+            return 1;
+          }
+          return 0;
+        }
+      end
+      compare.configure do
+        code %{
+          size_t remaining, ls, rs;
+          #{range} lr, rr;
+          assert(left);
+          assert(right);
+          ls = #{size.(left)}; 
+          rs = #{size.(right)};
+          /* comparing common parts */
+          for(
+            lr = #{range.new.(left)}, rr = #{range.new.(right)}, remaining = ls < rs ? ls : rs; /* min(ls, rs) */
+            remaining > 0;
+            #{range.pop_front.(:lr)}, #{range.pop_front.(:rr)}, --remaining
+          ) {
+            #{element.const_lvalue} le = #{range.view_front.(:lr)};
+            #{element.const_lvalue} re = #{range.view_front.(:rr)};
+            int c = #{element.compare.('*le', '*re')};
+            if(c != 0) {
+              return c; /* early exit on first non-equal pair encountered */
+            }
+          }
+          if(ls == rs) {
+            return 0; /* both vectors are completely equal */
+          } else {
+            return ls > rs ? +1 : -1; /* the longer sequence of the two with equal common part is considered "the more" */
+          }
+        }
+      end
+      hash_code.configure do
+        code %{
+          #{range} r;
+          size_t result;
+          #{hasher.to_s} hash;
+          #{hasher.create(:hash)};
+          for(r = #{range.new.(target)}; !#{range.empty.(:r)}; #{range.pop_front.(:r)}) {
+            #{element.const_lvalue} e = #{range.view_front.(:r)};
+            #{hasher.update(:hash, element.hash_code.('*e'))};
+          }
+          result = #{hasher.result(:hash)};
+          #{hasher.destroy(:hash)};
+          return result;
+        }
+      end
+    end
+
+  end # Sequential
+
+
+end