cgialib 0.0.1 → 0.0.2

data/Manifest.txt

@@ -5,8 +5,9 @@ README.rdoc
 Rakefile
 bin/testgen
 config/website.yml.sample
-features/development.feature
-features/steps/common.rb
+examples/ut/mytest1.c
+features/language_parser.feature
+features/steps/language_parser.rb
 features/steps/env.rb
 lib/cgialib.rb
 lib/testgen/cli.rb
@@ -17,6 +18,10 @@ lib/cgialib/lp/Tokenizer.rb
 lib/cgialib/lp/CLanguageScanner.rb
 lib/cgialib/lp/CPPLanguageScanner.rb
 lib/cgialib/lp/CTokenizer.rb
+lib/cgialib/lp/JavaDoc.rb
+lib/cgialib/lp/JavaLanguageScanner.rb
+lib/cgialib/lp/SQLTokenizer.rb
+lib/cgialib/lp/SQLLanguageScanner.rb
 lib/cgialib/template/ut.rb
 lib/cgialib/template/ut/c.rb
 script/console

data/Rakefile

@@ -8,9 +8,10 @@ $hoe = Hoe.new('cgialib', Cgialib::VERSION) do |p|
   p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
   p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
   p.rubyforge_name       = p.name # TODO this is default value
-  # p.extra_deps         = [
-  #   ['activesupport','>= 2.0.2'],
-  # ]
+  p.extra_deps         = [
+    ['cucumber','>= 0.1.9'],
+    ['rspec','>= 1.1.11']
+  ]
   p.extra_dev_deps = [
     ['newgem', ">= #{::Newgem::VERSION}"]
   ]

data/examples/ut/mytest1.c

@@ -0,0 +1,22 @@
+// Test case for the test case builder
+#include <stdio.h>
+
+// <test result="3"><a>1</a><b>2</b></test>
+// <test result="6"><a>2</a><b>4</b></test>
+// <test result="9"><a>3</a><b>6</b></test>
+int add( int a, int b ) { return a + b; }
+
+// <test result="3"><a>5</a><b>2</b></test>
+int minus( int a, int b ) { return a - b; }
+
+// <test result="30"><a>5</a><b>6</b></test>
+int multiply( int a, int b ) { return a * b; }
+
+int main( int argc, char *argv[] )
+{
+	run_tests();
+	printf( "%d\n", add( 1, 2 ) );
+	return 0;
+}
+
+

data/features/language_parser.feature

@@ -0,0 +1,21 @@
+Feature: Generate Unit Test for C by Language Parser
+
+  As a C language designer
+  I want testgen to generate unit tests for C source
+  So that I can spend time on designing code and test, not excessive time on writing test
+    
+  Scenario: Generate Unit Test
+    Given this project is active project folder
+    And 'examples/ut/mytest1.c' file is existed
+    And 'examples/ut/mytest1.c' file is copied to 'tmp' folder
+    And file 'tmp/mytest1.c' contains /\/\/ <test.*<\/test>/
+    When command 'testgen -s tmp/mytest1.c' is invoked
+    Then file 'tmp/mytest1.c.bak' is created
+    And file 'tmp/mytest1.c' contains /\/\/ <test_start>.*?\/\/ <\/test_start>/m
+  Scenario: Compile and Run the Unit Test
+    Given this project is active project folder
+    And file 'tmp/mytest1.c' contains /test_start/
+    When command 'gcc tmp/mytest1.c -o tmp/mytest1' is invoked
+    And command 'tmp/mytest1' is invoked
+    Then file 'tmp/tests.out' contains /\(100%\) Unit Test are passed/
+    

data/features/steps/language_parser.rb

@@ -0,0 +1,84 @@
+def in_project_folder(&block)
+  project_folder = @active_project_folder || @tmp_root
+  FileUtils.chdir(project_folder, &block)
+end
+Given %r{^this project is active project folder} do
+  Given "a safe folder"
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+Given %r{^a safe folder} do
+  #FileUtils.rm_rf   @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  FileUtils.mkdir_p @tmp_root
+  @lib_path = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+end
+Given %r{^env variable \$([\w_]+) set to '(.*)'} do |env_var, value|
+  ENV[env_var] = value
+end
+Given %r{'(.*)' folder is deleted} do |folder|
+  in_project_folder do
+    FileUtils.rm_rf folder
+  end
+end
+
+Given %r{'(.*)' file is copied to '(.*)' folder} do |file, folder|
+  in_project_folder do
+    system "cp #{file} #{folder}"
+  end
+end
+Given %r{'(.*)' file is existed} do |file|
+  in_project_folder do
+    File.exists?(file).should be_true
+  end
+end
+
+Given %r{'(.*)' file is deleted} do |file|
+  in_project_folder do
+    FileUtils.rm_rf file
+  end
+end
+
+When %r{^command 'testgen -s (.*\.c)' is invoked$} do |source_file|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  FileUtils.chdir(@active_project_folder) do
+    system "testgen -s #{source_file} > #{@stdout} 2> #{@stdout}"
+  end
+end
+When %r{^command 'gcc (.*\.c) (.*)' is invoked$} do |source_file,option|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  FileUtils.chdir(@active_project_folder) do
+    system "gcc #{source_file} #{option}> #{@stdout} 2> #{@stdout}"
+  end
+end
+When %r{^command '(tmp.*)' is invoked$} do |command|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  FileUtils.chdir(@active_project_folder) do
+    system " #{command}> #{@stdout} 2> #{@stdout}"
+  end
+end
+
+Then %r{^file '(.*)' contains \/(.*)\/$} do |file, regex|
+  in_project_folder do
+    file_content = File.read(file)
+    file_content.to_s.should match(/#{regex}/)
+  end
+end
+Then %r{^file '(.*)' contains \/(.*)\/m$} do |file, regex|
+  in_project_folder do
+    file_content = File.read(file)
+    file_content.to_s.should match(/#{regex}/m)
+  end
+end
+
+Then %r{^folder '(.*)' is created} do |folder|
+  in_project_folder do
+    File.exists?(folder).should be_true
+  end
+end
+
+Then %r{^file '(.*)' (is|is not) created} do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+

data/lib/cgialib/lp/JavaDoc.rb

@@ -0,0 +1,220 @@
+# File: JavaDoc.rb
+# Author: Jack Herrington
+# Purpose: Generic class for parsing JavaDoc comments
+# Date: 12/21/02
+
+module LanguageParser
+  # class : JavaDoc
+  #
+  # Simple JavaDoc interpreter.  This class holds JavaDoc tokens for a series of related JavaDoc
+  # comments. You should use one JavaDoc object per method or class. The JavaDoc object parses the
+  # comments, and stores the JavaDoc data in structured holders for easy access.
+  
+  class JavaDoc
+  
+    # initialize()
+    #
+    # Builds the JavaDoc class
+  
+    def initialize()
+  
+      # Hash to hold the @name tags. The default text goes into a tag named
+      # '@desc'.
+  
+      @tags = { '@desc' => "" }
+  
+      # Special holder for the @param values
+  
+      @params = {}
+  
+    end
+  
+    attr_reader :tags       # The tag contents
+  
+    attr_reader :params     # The @param contents
+  
+    # to_s()
+    #
+    # Pretty prints the current contents of this JavaDoc object
+  
+    def to_s()
+  
+      text = ""
+  
+      @tags.each_key { |k| text += "#{k} : #{@tags[k]}\n" }
+  
+      @params.each_key { |k| text += "param(#{k}) : #{@params[k]}\n" }
+  
+      text
+  
+    end
+  
+    # parse( text )
+    #
+    # text - The JavaDoc comment
+    #
+    # Parses the JavaDoc comment and stores the contents
+  
+    def parse( text )
+  
+      # Strip leading and trailing space
+  
+      text.strip!
+  
+      # Return unless we see the distinctive '/**' JavaDoc beginning
+      # marker
+  
+      return unless ( text =~ /^\/\*\*/ || text =~ /^\*/ )
+  
+      # This section removes all of the leading stars, the comment lines
+      # and anything around the text
+  
+      cleaned = ""
+      text.each_line { |line|
+  
+        line.strip!
+  
+        line.sub!( /^\/\*\*/, "" )
+        line.sub!( /^\*\//, "" )
+        line.sub!( /^\*\s*/, "" )
+  
+        line.strip!
+  
+        next if line.length < 1
+  
+        cleaned += "#{line}\n"
+  
+      }
+  
+      # This section is a mini-tokenizer that splits the content of the string
+      # into an array.  The delimiter is whitespace.  The whitespace is stored
+      # in the array as well as it may be important to some tags.
+  
+      in_whitespace = false
+      text = ""
+      tokens = []
+  
+      cleaned.each_byte { |ch|
+  
+        ch = ch.chr()
+  
+        if ( ch =~ /\s/ )
+  
+          if ( in_whitespace )
+  
+            text += ch
+  
+          else
+  
+            tokens.push( text ) if ( text.length > 0 )
+            text = ch
+            in_whitespace = true
+  
+          end
+  
+        else
+  
+          if ( in_whitespace )
+  
+            tokens.push( text ) if ( text.length > 0 )
+            text = ch
+            in_whitespace = false
+  
+          else
+  
+            text += ch
+  
+          end
+  
+        end
+  
+      }
+  
+      tokens.push( text ) if ( text.length > 0 )
+  
+      # Now we use our 'tokenized' array and search for the '@tag' items. As
+      # we go through the tokens we are building a buffer.  When we reach a 
+      # new tag we send the buffer on to add_to_tag.
+  
+      cur_name = "@desc"
+      buffer = ""
+  
+      tokens.each { |tok|
+  
+        if ( tok =~ /^@/ )
+  
+          add_to_tag( cur_name, buffer ) if ( buffer.length > 0 )
+          buffer = ""
+  
+          cur_name = tok
+  
+        else
+  
+          buffer += tok
+  
+        end
+  
+      }
+  
+      # Make sure we get the contents of the buffer at the end
+  
+      add_to_tag( cur_name, buffer ) if ( buffer.length > 0 )
+  
+      # Invoke the tag cleaner
+  
+      clean_tags()
+  
+    end
+  
+  protected
+  
+    # add_to_tag( key, text )
+    #
+    # key - The tag name (e.g. '@see' )
+    # text - The text of the tag
+    #
+    # This adds some more text to the tag. This is the method you would
+    # override if you wanted to add your own JavaDoc tag to a parser, but
+    # only if that tag had special parsing requirements.
+  
+    def add_to_tag( key, text )
+  
+      if ( key == "@param" )
+  
+        # If this is a param then we handle it seperately
+        # by storing it's contents into a hash
+  
+        text.strip!
+  
+        text =~ /^(.*?)\s/
+        name = $1
+        text.sub!( /^(.*?)\s/, "" )
+  
+        text.strip!
+  
+        @params[ name ] = text
+  
+      else
+  
+        # Otherwise we just append it to the tag text in the
+        # tag hash
+  
+        @tags[ key ] = "" unless ( @tags.has_key?( key ) )
+        @tags[ key ] += text
+  
+      end
+  
+    end
+  
+    # clean_tags()
+    #
+    # A process step method that cleans up the tags after they are read in.
+  
+    def clean_tags()
+  
+      @tags.each_key { |k| @tags[ k ].strip! }
+  
+    end
+  
+  end
+end