backbone-forms-on-rails 0.10.0

data/vendor/bundle/gems/rdoc-3.12/test/test_rdoc_parser.rb

@@ -0,0 +1,162 @@
+require 'rdoc/test_case'
+
+class TestRDocParser < RDoc::TestCase
+
+  def setup
+    super
+
+    @RP = RDoc::Parser
+    @binary_dat = File.expand_path '../binary.dat', __FILE__
+
+    @fn = 'file.rb'
+    @top_level = RDoc::TopLevel.new @fn
+    @options = RDoc::Options.new
+  end
+
+  def test_class_binary_eh_marshal
+    marshal = File.join Dir.tmpdir, "test_rdoc_parser_#{$$}.marshal"
+    open marshal, 'wb' do |io|
+      io.write Marshal.dump('')
+      io.write 'lots of text ' * 500
+    end
+
+    assert @RP.binary?(marshal)
+  ensure
+    File.unlink marshal
+  end
+
+  def test_class_binary_japanese_text
+    file_name = File.expand_path '../test.ja.txt', __FILE__
+    refute @RP.binary?(file_name)
+  end
+
+  def test_class_binary_large_japanese_rdoc
+    file_name = File.expand_path '../test.ja.large.rdoc', __FILE__
+    assert !@RP.binary?(file_name)
+  end
+
+  def test_class_binary_japanese_rdoc
+    skip "Encoding not implemented" unless Object.const_defined? :Encoding
+
+    file_name = File.expand_path '../test.ja.rdoc', __FILE__
+    refute @RP.binary?(file_name)
+  end
+
+  def test_class_can_parse
+    assert_equal @RP.can_parse(__FILE__), @RP::Ruby
+
+    readme_file_name = File.expand_path '../test.txt', __FILE__
+
+    assert_equal @RP::Simple, @RP.can_parse(readme_file_name)
+
+    assert_nil @RP.can_parse(@binary_dat)
+
+    jtest_file_name = File.expand_path '../test.ja.txt', __FILE__
+    assert_equal @RP::Simple, @RP.can_parse(jtest_file_name)
+
+    jtest_rdoc_file_name = File.expand_path '../test.ja.rdoc', __FILE__
+    assert_equal @RP::Simple, @RP.can_parse(jtest_rdoc_file_name)
+
+    readme_file_name = File.expand_path '../README', __FILE__
+    assert_equal @RP::Simple, @RP.can_parse(readme_file_name)
+  end
+
+  ##
+  # Selenium hides a .jar file using a .txt extension.
+
+  def test_class_can_parse_zip
+    hidden_zip = File.expand_path '../hidden.zip.txt', __FILE__
+    assert_nil @RP.can_parse(hidden_zip)
+  end
+
+  def test_class_for_binary
+    rp = @RP.dup
+
+    class << rp
+      alias old_can_parse can_parse
+    end
+
+    def rp.can_parse(*args) nil end
+
+    assert_nil @RP.for(nil, @binary_dat, nil, nil, nil)
+  end
+
+  def test_class_for_markup
+    content = <<-CONTENT
+# coding: utf-8 markup: rd
+    CONTENT
+
+    parser = @RP.for @top_level, __FILE__, content, @options, nil
+
+    assert_kind_of @RP::RD, parser
+  end
+
+  def test_class_use_markup
+    content = <<-CONTENT
+# coding: utf-8 markup: rd
+    CONTENT
+
+    parser = @RP.use_markup content
+
+    assert_equal @RP::RD, parser
+  end
+
+  def test_class_use_markup_modeline
+    content = <<-CONTENT
+# -*- coding: utf-8 -*-
+# markup: rd
+    CONTENT
+
+    parser = @RP.use_markup content
+
+    assert_equal @RP::RD, parser
+  end
+
+  def test_class_use_markup_modeline_shebang
+    content = <<-CONTENT
+#!/bin/sh
+/* -*- coding: utf-8 -*-
+ * markup: rd
+ */
+    CONTENT
+
+    parser = @RP.use_markup content
+
+    assert_equal @RP::RD, parser
+  end
+
+  def test_class_use_markup_shebang
+    content = <<-CONTENT
+#!/usr/bin/env ruby
+# coding: utf-8 markup: rd
+    CONTENT
+
+    parser = @RP.use_markup content
+
+    assert_equal @RP::RD, parser
+  end
+
+  def test_class_use_markup_tomdoc
+    content = <<-CONTENT
+# coding: utf-8 markup: tomdoc
+    CONTENT
+
+    parser = @RP.use_markup content
+
+    assert_equal @RP::Ruby, parser
+  end
+
+  def test_class_use_markup_none
+    parser = @RP.use_markup ''
+
+    assert_nil parser
+  end
+
+  def test_initialize
+    @RP.new @top_level, @fn, '', @options, nil
+
+    assert_equal @RP, @top_level.parser
+  end
+
+end
+

data/vendor/bundle/gems/rdoc-3.12/test/test_rdoc_parser_c.rb

@@ -0,0 +1,1438 @@
+require 'rdoc/test_case'
+
+=begin
+  TODO: test call-seq parsing
+
+/*
+ *  call-seq:
+ *     ARGF.readlines(sep=$/)     -> array
+ *     ARGF.readlines(limit)      -> array
+ *     ARGF.readlines(sep, limit) -> array
+ *
+ *     ARGF.to_a(sep=$/)     -> array
+ *     ARGF.to_a(limit)      -> array
+ *     ARGF.to_a(sep, limit) -> array
+ *
+ *  Reads +ARGF+'s current file in its entirety, returning an +Array+ of its
+ *  lines, one line per element. Lines are assumed to be separated by _sep_.
+ *
+ *     lines = ARGF.readlines
+ *     lines[0]                #=> "This is line one\n"
+ */
+
+assert call-seq did not stop at first empty line
+
+/*
+ * call-seq:
+ *
+ *  flt ** other  ->  float
+ *
+ * Raises <code>float</code> the <code>other</code> power.
+ *
+ *    2.0**3      #=> 8.0
+ */
+
+assert call-seq correct (bug: was empty)
+
+/* call-seq: flt ** other  ->  float */
+
+assert call-seq correct
+
+=end
+
+class RDoc::Parser::C
+  attr_accessor :classes
+
+  public :do_classes, :do_constants
+end
+
+class TestRDocParserC < RDoc::TestCase
+
+  def setup
+    super
+
+    @tempfile = Tempfile.new self.class.name
+    filename = @tempfile.path
+
+    @top_level = RDoc::TopLevel.new filename
+    @fn = filename
+    @options = RDoc::Options.new
+    @options.verbosity = 2
+    @stats = RDoc::Stats.new 0
+  end
+
+  def teardown
+    super
+
+    @tempfile.close
+  end
+
+  def test_class_can_parse
+    c_parser = RDoc::Parser::C
+
+    assert_equal c_parser, c_parser.can_parse('file.C')
+    assert_equal c_parser, c_parser.can_parse('file.CC')
+    assert_equal c_parser, c_parser.can_parse('file.H')
+    assert_equal c_parser, c_parser.can_parse('file.HH')
+    assert_equal c_parser, c_parser.can_parse('file.c')
+    assert_equal c_parser, c_parser.can_parse('file.cc')
+    assert_equal c_parser, c_parser.can_parse('file.cpp')
+    assert_equal c_parser, c_parser.can_parse('file.cxx')
+    assert_equal c_parser, c_parser.can_parse('file.h')
+    assert_equal c_parser, c_parser.can_parse('file.hh')
+    assert_equal c_parser, c_parser.can_parse('file.y')
+  end
+
+  def test_do_attr_rb_attr
+    content = <<-EOF
+void Init_Blah(void) {
+  cBlah = rb_define_class("Blah", rb_cObject);
+
+  /*
+   * This is an accessor
+   */
+  rb_attr(cBlah, rb_intern("accessor"), 1, 1, Qfalse);
+
+  /*
+   * This is a reader
+   */
+  rb_attr(cBlah, rb_intern("reader"), 1, 0, Qfalse);
+
+  /*
+   * This is a writer
+   */
+  rb_attr(cBlah, rb_intern("writer"), 0, 1, Qfalse);
+}
+    EOF
+
+    klass = util_get_class content, 'cBlah'
+
+    attrs = klass.attributes
+    assert_equal 3, attrs.length, attrs.inspect
+
+    accessor = attrs.shift
+    assert_equal 'accessor',            accessor.name
+    assert_equal 'RW',                  accessor.rw
+    assert_equal 'This is an accessor', accessor.comment.text
+    assert_equal @top_level,            accessor.file
+
+    reader = attrs.shift
+    assert_equal 'reader',           reader.name
+    assert_equal 'R',                reader.rw
+    assert_equal 'This is a reader', reader.comment.text
+
+    writer = attrs.shift
+    assert_equal 'writer',           writer.name
+    assert_equal 'W',                writer.rw
+    assert_equal 'This is a writer', writer.comment.text
+  end
+
+  def test_do_attr_rb_define_attr
+    content = <<-EOF
+void Init_Blah(void) {
+  cBlah = rb_define_class("Blah", rb_cObject);
+
+  /*
+   * This is an accessor
+   */
+  rb_define_attr(cBlah, "accessor", 1, 1);
+}
+    EOF
+
+    klass = util_get_class content, 'cBlah'
+
+    attrs = klass.attributes
+    assert_equal 1, attrs.length, attrs.inspect
+
+    accessor = attrs.shift
+    assert_equal 'accessor',            accessor.name
+    assert_equal 'RW',                  accessor.rw
+    assert_equal 'This is an accessor', accessor.comment.text
+    assert_equal @top_level,            accessor.file
+  end
+
+  def test_do_aliases
+    content = <<-EOF
+/*
+ * This should show up as an alias with documentation
+ */
+VALUE blah(VALUE klass, VALUE year) {
+}
+
+void Init_Blah(void) {
+  cDate = rb_define_class("Date", rb_cObject);
+
+  rb_define_method(cDate, "blah", blah, 1);
+
+  rb_define_alias(cDate, "bleh", "blah");
+}
+    EOF
+
+    klass = util_get_class content, 'cDate'
+
+    methods = klass.method_list
+    assert_equal 2,      methods.length
+    assert_equal 'bleh', methods.last.name
+    assert_equal 'blah', methods.last.is_alias_for.name
+
+    assert_equal @top_level, methods.last.is_alias_for.file
+    assert_equal @top_level, methods.last.file
+  end
+
+  def test_do_aliases_singleton
+    content = <<-EOF
+/*
+ * This should show up as a method with documentation
+ */
+VALUE blah(VALUE klass, VALUE year) {
+}
+
+void Init_Blah(void) {
+  cDate = rb_define_class("Date", rb_cObject);
+  sDate = rb_singleton_class(cDate);
+
+  rb_define_method(sDate, "blah", blah, 1);
+
+  /*
+   * This should show up as an alias
+   */
+  rb_define_alias(sDate, "bleh", "blah");
+}
+    EOF
+
+    klass = util_get_class content, 'cDate'
+
+    methods = klass.method_list
+
+    assert_equal 2,      methods.length
+    assert_equal 'bleh', methods.last.name
+    assert               methods.last.singleton
+    assert_equal 'blah', methods.last.is_alias_for.name
+    assert_equal 'This should show up as an alias', methods.last.comment.text
+  end
+
+  def test_do_classes_boot_class
+    content = <<-EOF
+/* Document-class: Foo
+ * this is the Foo boot class
+ */
+VALUE cFoo = boot_defclass("Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal "this is the Foo boot class", klass.comment.text
+    assert_equal 'Object', klass.superclass
+  end
+
+  def test_do_classes_boot_class_nil
+    content = <<-EOF
+/* Document-class: Foo
+ * this is the Foo boot class
+ */
+VALUE cFoo = boot_defclass("Foo", 0);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal "this is the Foo boot class", klass.comment.text
+    assert_equal nil, klass.superclass
+  end
+
+  def test_do_aliases_missing_class
+    content = <<-EOF
+void Init_Blah(void) {
+  rb_define_alias(cDate, "b", "a");
+}
+    EOF
+
+    _, err = capture_io do
+      refute util_get_class(content, 'cDate')
+    end
+
+    assert_equal "Enclosing class/module \"cDate\" for alias b a not known\n",
+                 err
+  end
+
+  def test_do_classes_class
+    content = <<-EOF
+/* Document-class: Foo
+ * this is the Foo class
+ */
+VALUE cFoo = rb_define_class("Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal "this is the Foo class", klass.comment.text
+  end
+
+  def test_do_classes_struct
+    content = <<-EOF
+/* Document-class: Foo
+ * this is the Foo class
+ */
+VALUE cFoo = rb_struct_define_without_accessor(
+        "Foo", rb_cObject, foo_alloc,
+        "some", "various", "fields", NULL);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal "this is the Foo class", klass.comment.text
+  end
+
+  def test_do_classes_class_under
+    content = <<-EOF
+/* Document-class: Kernel::Foo
+ * this is the Foo class under Kernel
+ */
+VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal 'Kernel::Foo', klass.full_name
+    assert_equal "this is the Foo class under Kernel", klass.comment.text
+  end
+
+  def test_do_classes_class_under_rb_path2class
+    content = <<-EOF
+/* Document-class: Kernel::Foo
+ * this is Kernel::Foo < A::B
+ */
+VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_path2class("A::B"));
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+
+    assert_equal 'Kernel::Foo', klass.full_name
+    assert_equal 'A::B', klass.superclass
+    assert_equal 'this is Kernel::Foo < A::B', klass.comment.text
+  end
+
+  def test_do_classes_singleton
+    content = <<-EOF
+VALUE cFoo = rb_define_class("Foo", rb_cObject);
+VALUE cFooS = rb_singleton_class(cFoo);
+    EOF
+
+    util_get_class content, 'cFooS'
+
+    assert_equal 'Foo', @parser.singleton_classes['cFooS']
+  end
+
+  def test_do_classes_module
+    content = <<-EOF
+/* Document-module: Foo
+ * this is the Foo module
+ */
+VALUE mFoo = rb_define_module("Foo");
+    EOF
+
+    klass = util_get_class content, 'mFoo'
+    assert_equal "this is the Foo module", klass.comment.text
+  end
+
+  def test_do_classes_module_under
+    content = <<-EOF
+/* Document-module: Kernel::Foo
+ * this is the Foo module under Kernel
+ */
+VALUE mFoo = rb_define_module_under(rb_mKernel, "Foo");
+    EOF
+
+    klass = util_get_class content, 'mFoo'
+    assert_equal "this is the Foo module under Kernel", klass.comment.text
+  end
+
+  def test_do_constants
+    content = <<-EOF
+#include <ruby.h>
+
+void Init_foo(){
+   VALUE cFoo = rb_define_class("Foo", rb_cObject);
+
+   /* 300: The highest possible score in bowling */
+   rb_define_const(cFoo, "PERFECT", INT2FIX(300));
+
+   /* Huzzah!: What you cheer when you roll a perfect game */
+   rb_define_const(cFoo, "CHEER", rb_str_new2("Huzzah!"));
+
+   /* TEST\:TEST: Checking to see if escaped colon works */
+   rb_define_const(cFoo, "TEST", rb_str_new2("TEST:TEST"));
+
+   /* \\: The file separator on MS Windows */
+   rb_define_const(cFoo, "MSEPARATOR", rb_str_new2("\\"));
+
+   /* /: The file separator on Unix */
+   rb_define_const(cFoo, "SEPARATOR", rb_str_new2("/"));
+
+   /* C:\\Program Files\\Stuff: A directory on MS Windows */
+   rb_define_const(cFoo, "STUFF", rb_str_new2("C:\\Program Files\\Stuff"));
+
+   /* Default definition */
+   rb_define_const(cFoo, "NOSEMI", INT2FIX(99));
+
+   rb_define_const(cFoo, "NOCOMMENT", rb_str_new2("No comment"));
+
+   /*
+    * Multiline comment goes here because this comment spans multiple lines.
+    * Multiline comment goes here because this comment spans multiple lines.
+    */
+   rb_define_const(cFoo, "MULTILINE", INT2FIX(1));
+
+   /*
+    * 1: Multiline comment goes here because this comment spans multiple lines.
+    * Multiline comment goes here because this comment spans multiple lines.
+    */
+   rb_define_const(cFoo, "MULTILINE_VALUE", INT2FIX(1));
+
+   /* Multiline comment goes here because this comment spans multiple lines.
+    * Multiline comment goes here because this comment spans multiple lines.
+    */
+   rb_define_const(cFoo, "MULTILINE_NOT_EMPTY", INT2FIX(1));
+
+}
+    EOF
+
+    @parser = util_parser content
+
+    @parser.do_classes
+    @parser.do_constants
+
+    klass = @parser.classes['cFoo']
+    assert klass
+
+    constants = klass.constants
+    assert !klass.constants.empty?
+
+    assert_equal @top_level, constants.first.file
+
+    constants = constants.map { |c| [c.name, c.value, c.comment.text] }
+
+    assert_equal ['PERFECT', '300', 'The highest possible score in bowling   '],
+                 constants.shift
+    assert_equal ['CHEER', 'Huzzah!',
+                  'What you cheer when you roll a perfect game   '],
+                 constants.shift
+    assert_equal ['TEST', 'TEST:TEST',
+                  'Checking to see if escaped colon works   '],
+                 constants.shift
+    assert_equal ['MSEPARATOR', '\\',
+                  'The file separator on MS Windows   '],
+                 constants.shift
+    assert_equal ['SEPARATOR', '/',
+                  'The file separator on Unix   '],
+                 constants.shift
+    assert_equal ['STUFF', 'C:\\Program Files\\Stuff',
+                  'A directory on MS Windows   '],
+                 constants.shift
+    assert_equal ['NOSEMI', 'INT2FIX(99)',
+                  'Default definition   '],
+                 constants.shift
+    assert_equal ['NOCOMMENT', 'rb_str_new2("No comment")', ''],
+                 constants.shift
+
+    comment = <<-EOF.chomp
+Multiline comment goes here because this comment spans multiple lines.
+Multiline comment goes here because this comment spans multiple lines.
+    EOF
+    assert_equal ['MULTILINE',           'INT2FIX(1)', comment], constants.shift
+    assert_equal ['MULTILINE_VALUE',     '1',          comment], constants.shift
+    assert_equal ['MULTILINE_NOT_EMPTY', 'INT2FIX(1)', comment], constants.shift
+
+    assert constants.empty?, constants.inspect
+  end
+
+  def test_do_constants_curses
+    content = <<-EOF
+void Init_curses(){
+  mCurses = rb_define_module("Curses");
+
+  /*
+   * Document-const: Curses::COLOR_BLACK
+   *
+   * Value of the color black
+   */
+  rb_curses_define_const(COLOR_BLACK);
+}
+    EOF
+
+    @parser = util_parser content
+
+    @parser.do_classes
+    @parser.do_constants
+
+    klass = @parser.classes['mCurses']
+
+    constants = klass.constants
+    refute_empty klass.constants
+
+    assert_equal 'COLOR_BLACK', constants.first.name
+    assert_equal 'UINT2NUM(COLOR_BLACK)', constants.first.value
+    assert_equal 'Value of the color black', constants.first.comment.text
+  end
+
+  def test_do_includes
+    content = <<-EOF
+Init_foo() {
+   VALUE cFoo = rb_define_class("Foo", rb_cObject);
+   VALUE mInc = rb_define_module("Inc");
+
+   rb_include_module(cFoo, mInc);
+}
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+
+    incl = klass.includes.first
+    assert_equal 'Inc',      incl.name
+    assert_equal '',         incl.comment.text
+    assert_equal @top_level, incl.file
+  end
+
+  # HACK parsing warning instead of setting up in file
+  def test_do_methods_in_c
+    content = <<-EOF
+VALUE blah(VALUE klass, VALUE year) {
+}
+
+void Init_Blah(void) {
+  cDate = rb_define_class("Date", rb_cObject);
+
+  rb_define_method(cDate, "blah", blah, 1); /* in blah.c */
+}
+    EOF
+
+    klass = nil
+
+    _, err = capture_io do
+      klass = util_get_class content, 'cDate'
+    end
+
+    assert_match ' blah.c ', err
+  end
+
+  # HACK parsing warning instead of setting up in file
+  def test_do_methods_in_cpp
+    content = <<-EOF
+VALUE blah(VALUE klass, VALUE year) {
+}
+
+void Init_Blah(void) {
+  cDate = rb_define_class("Date", rb_cObject);
+
+  rb_define_method(cDate, "blah", blah, 1); /* in blah.cpp */
+}
+    EOF
+
+    klass = nil
+
+    _, err = capture_io do
+      klass = util_get_class content, 'cDate'
+    end
+
+    assert_match ' blah.cpp ', err
+  end
+
+  # HACK parsing warning instead of setting up in file
+  def test_do_methods_in_y
+    content = <<-EOF
+VALUE blah(VALUE klass, VALUE year) {
+}
+
+void Init_Blah(void) {
+  cDate = rb_define_class("Date", rb_cObject);
+
+  rb_define_method(cDate, "blah", blah, 1); /* in blah.y */
+}
+    EOF
+
+    klass = nil
+
+    _, err = capture_io do
+      klass = util_get_class content, 'cDate'
+    end
+
+    assert_match ' blah.y ', err
+  end
+
+  def test_do_methods_singleton_class
+    content = <<-EOF
+VALUE blah(VALUE klass, VALUE year) {
+}
+
+void Init_Blah(void) {
+  cDate = rb_define_class("Date", rb_cObject);
+  sDate = rb_singleton_class(cDate);
+
+  rb_define_method(sDate, "blah", blah, 1);
+}
+    EOF
+
+    klass = util_get_class content, 'cDate'
+
+    methods = klass.method_list
+    assert_equal 1,      methods.length
+    assert_equal 'blah', methods.first.name
+    assert               methods.first.singleton
+  end
+
+  def test_find_alias_comment
+    parser = util_parser ''
+
+    comment = parser.find_alias_comment 'C', '[]', 'index'
+
+    assert_equal '', comment.text
+
+    parser = util_parser <<-C
+/*
+ * comment
+ */
+
+rb_define_alias(C, "[]", "index");
+    C
+
+    comment = parser.find_alias_comment 'C', '[]', 'index'
+
+    assert_equal "/*\n * comment\n */\n\n", comment.text
+  end
+
+  def test_find_class_comment_include
+    @options.rdoc_include << File.dirname(__FILE__)
+
+    content = <<-EOF
+/*
+ * a comment for class Foo
+ *
+ * :include: test.txt
+ */
+void
+Init_Foo(void) {
+  VALUE foo = rb_define_class("Foo", rb_cObject);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "a comment for class Foo\n\ntest file\n", klass.comment.text
+  end
+
+  def test_find_class_comment_init
+    content = <<-EOF
+/*
+ * a comment for class Foo
+ */
+void
+Init_Foo(void) {
+  VALUE foo = rb_define_class("Foo", rb_cObject);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "a comment for class Foo", klass.comment.text
+  end
+
+  def test_find_class_comment_define_class
+    content = <<-EOF
+/*
+ * a comment for class Foo
+ */
+VALUE foo = rb_define_class("Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "a comment for class Foo", klass.comment.text
+  end
+
+  def test_find_class_comment_define_class_Init_Foo
+    content = <<-EOF
+/*
+ * a comment for class Foo on Init
+ */
+void
+Init_Foo(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "a comment for class Foo on Init", klass.comment.text
+  end
+
+  def test_find_class_comment_define_class_Init_Foo_no_void
+    content = <<-EOF
+/*
+ * a comment for class Foo on Init
+ */
+void
+Init_Foo() {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "a comment for class Foo on Init", klass.comment.text
+  end
+
+  def test_find_class_comment_define_class_bogus_comment
+    content = <<-EOF
+/*
+ * a comment for other_function
+ */
+void
+other_function() {
+}
+
+void
+Init_Foo(void) {
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal '', klass.comment.text
+  end
+
+  def test_find_class_comment_define_class_under
+    content = <<-EOF
+/*
+ * a comment for class Foo
+ */
+VALUE foo = rb_define_class_under(rb_cObject, "Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "a comment for class Foo", klass.comment.text
+  end
+
+  def test_find_class_comment_define_class_under_Init
+    content = <<-EOF
+/*
+ * a comment for class Foo on Init
+ */
+void
+Init_Foo(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE foo = rb_define_class_under(rb_cObject, "Foo", rb_cObject);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    # the inner comment is used since Object::Foo is not necessarily the same
+    # thing as "Foo" for Init_
+    assert_equal "a comment for class Foo on rb_define_class",
+                 klass.comment.text
+  end
+
+  def test_find_const_comment_rb_define
+    content = <<-EOF
+/*
+ * A comment
+ */
+rb_define_const(cFoo, "CONST", value);
+    EOF
+
+    parser = util_parser content
+
+    comment = parser.find_const_comment 'const', 'CONST'
+
+    assert_equal "/*\n * A comment\n */\n", comment.text
+  end
+
+  def test_find_const_comment_document_const
+    content = <<-EOF
+/*
+ * Document-const: CONST
+ *
+ * A comment
+ */
+    EOF
+
+    parser = util_parser content
+
+    comment = parser.find_const_comment nil, 'CONST'
+
+    assert_equal "/*\n *\n * A comment\n */", comment.text
+  end
+
+  def test_find_const_comment_document_const_full_name
+    content = <<-EOF
+/*
+ * Document-const: Foo::CONST
+ *
+ * A comment
+ */
+    EOF
+
+    parser = util_parser content
+
+    comment = parser.find_const_comment nil, 'CONST', 'Foo'
+
+    assert_equal "/*\n *\n * A comment\n */", comment.text
+  end
+
+  def test_find_body
+    content = <<-EOF
+/*
+ * a comment for other_function
+ */
+VALUE
+other_function() {
+}
+
+void
+Init_Foo(void) {
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+
+    rb_define_method(foo, "my_method", other_function, 0);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+    other_function = klass.method_list.first
+
+    assert_equal 'my_method', other_function.name
+    assert_equal "a comment for other_function",
+                 other_function.comment.text
+    assert_equal '()', other_function.params
+
+    code = other_function.token_stream.first.text
+
+    assert_equal "VALUE\nother_function() {\n}", code
+  end
+
+  def test_find_body_2
+    content = <<-CONTENT
+/* Copyright (C) 2010  Sven Herzberg
+ *
+ * This file is free software; the author(s) gives unlimited
+ * permission to copy and/or distribute it, with or without
+ * modifications, as long as this notice is preserved.
+ */
+
+#include <ruby.h>
+
+static VALUE
+wrap_initialize (VALUE  self)
+{
+  return self;
+}
+
+/* */
+static VALUE
+wrap_shift (VALUE self,
+            VALUE arg)
+{
+  return self;
+}
+
+void
+init_gi_repository (void)
+{
+  VALUE mTest = rb_define_module ("Test");
+  VALUE cTest = rb_define_class_under (mTest, "Test", rb_cObject);
+
+  rb_define_method (cTest, "initialize", wrap_initialize, 0);
+  rb_define_method (cTest, "shift", wrap_shift, 0);
+}
+    CONTENT
+
+    klass = util_get_class content, 'cTest'
+    assert_equal 2, klass.method_list.length
+  end
+
+  def test_find_body_define
+    content = <<-EOF
+#define something something_else
+
+#define other_function rb_other_function
+
+/*
+ * a comment for rb_other_function
+ */
+VALUE
+rb_other_function() {
+}
+
+void
+Init_Foo(void) {
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+
+    rb_define_method(foo, "my_method", other_function, 0);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+    other_function = klass.method_list.first
+
+    assert_equal 'my_method', other_function.name
+    assert_equal 'a comment for rb_other_function', other_function.comment.text
+    assert_equal '()', other_function.params
+    assert_equal 118, other_function.offset
+    assert_equal 8, other_function.line
+
+    code = other_function.token_stream.first.text
+
+    assert_equal "VALUE\nrb_other_function() {\n}", code
+  end
+
+  def test_find_body_define_comment
+    content = <<-EOF
+/*
+ * a comment for other_function
+ */
+#define other_function rb_other_function
+
+/* */
+VALUE
+rb_other_function() {
+}
+
+void
+Init_Foo(void) {
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+
+    rb_define_method(foo, "my_method", other_function, 0);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+    other_function = klass.method_list.first
+
+    assert_equal 'my_method', other_function.name
+    assert_equal 'a comment for other_function', other_function.comment.text
+    assert_equal '()', other_function.params
+    assert_equal 39, other_function.offset
+    assert_equal 4, other_function.line
+
+    code = other_function.token_stream.first.text
+
+    assert_equal "#define other_function rb_other_function", code
+  end
+
+  def test_find_body_document_method
+    content = <<-EOF
+/*
+ * Document-method: bar
+ * Document-method: baz
+ *
+ * a comment for bar
+ */
+VALUE
+bar() {
+}
+
+void
+Init_Foo(void) {
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+
+    rb_define_method(foo, "bar", bar, 0);
+    rb_define_method(foo, "baz", bar, 0);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+    assert_equal 2, klass.method_list.length
+
+    methods = klass.method_list.sort
+
+    bar = methods.first
+    assert_equal 'Foo#bar', bar.full_name
+    assert_equal "a comment for bar", bar.comment.text
+
+    baz = methods.last
+    assert_equal 'Foo#baz', baz.full_name
+    assert_equal "a comment for bar", baz.comment.text
+  end
+
+  def test_find_body_document_method_equals
+    content = <<-EOF
+/*
+ * Document-method: Zlib::GzipFile#mtime=
+ *
+ * A comment
+ */
+static VALUE
+rb_gzfile_set_mtime(VALUE obj, VALUE mtime)
+{
+
+void
+Init_zlib() {
+    mZlib = rb_define_module("Zlib");
+    cGzipFile = rb_define_class_under(mZlib, "GzipFile", rb_cObject);
+    cGzipWriter = rb_define_class_under(mZlib, "GzipWriter", cGzipFile);
+    rb_define_method(cGzipWriter, "mtime=", rb_gzfile_set_mtime, 1);
+}
+    EOF
+
+    klass = util_get_class content, 'cGzipWriter'
+    assert_equal 1, klass.method_list.length
+
+    methods = klass.method_list.sort
+
+    bar = methods.first
+    assert_equal 'Zlib::GzipWriter#mtime=', bar.full_name
+    assert_equal 'A comment', bar.comment.text
+  end
+
+  def test_find_body_document_method_same
+    content = <<-EOF
+VALUE
+s_bar() {
+}
+
+VALUE
+bar() {
+}
+
+/*
+ * Document-method: Foo::bar
+ *
+ * a comment for Foo::bar
+ */
+
+/*
+ * Document-method: Foo#bar
+ *
+ * a comment for Foo#bar
+ */
+
+void
+Init_Foo(void) {
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+
+    rb_define_singleton_method(foo, "bar", s_bar, 0);
+    rb_define_method(foo, "bar", bar, 0);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+    assert_equal 2, klass.method_list.length
+
+    methods = klass.method_list.sort
+
+    s_bar = methods.first
+    assert_equal 'Foo::bar', s_bar.full_name
+    assert_equal "a comment for Foo::bar", s_bar.comment.text
+
+    bar = methods.last
+    assert_equal 'Foo#bar', bar.full_name
+    assert_equal "a comment for Foo#bar", bar.comment.text
+  end
+
+  def test_find_modifiers_call_seq
+    comment = RDoc::Comment.new <<-COMMENT
+call-seq:
+  commercial() -> Date <br />
+
+If no arguments are given:
+
+    COMMENT
+
+    parser = util_parser ''
+    method_obj = RDoc::AnyMethod.new nil, 'blah'
+
+    parser.find_modifiers comment, method_obj
+
+    expected = <<-CALL_SEQ.chomp
+commercial() -> Date <br />
+
+    CALL_SEQ
+
+    assert_equal expected, method_obj.call_seq
+  end
+
+  def test_find_modifiers_nodoc
+    comment = RDoc::Comment.new <<-COMMENT
+/* :nodoc:
+ *
+ * Blah
+ */
+
+    COMMENT
+
+    parser = util_parser ''
+    method_obj = RDoc::AnyMethod.new nil, 'blah'
+
+    parser.find_modifiers comment, method_obj
+
+    assert_equal nil, method_obj.document_self
+  end
+
+  def test_find_modifiers_yields
+    comment = RDoc::Comment.new <<-COMMENT
+/* :yields: a, b
+ *
+ * Blah
+ */
+
+    COMMENT
+
+    parser = util_parser ''
+    method_obj = RDoc::AnyMethod.new nil, 'blah'
+
+    parser.find_modifiers comment, method_obj
+
+    assert_equal 'a, b', method_obj.block_params
+
+    assert_equal "\n\nBlah", comment.text
+  end
+
+  def test_handle_method_args_minus_1
+    parser = util_parser "Document-method: Object#m\n blah */"
+
+    parser.content = <<-BODY
+VALUE
+rb_other(VALUE obj) {
+  rb_funcall(obj, rb_intern("other"), 0);
+  return rb_str_new2("blah, blah, blah");
+}
+
+VALUE
+rb_m(int argc, VALUE *argv, VALUE obj) {
+  VALUE o1, o2;
+  rb_scan_args(argc, argv, "1", &o1, &o2);
+}
+    BODY
+
+    parser.handle_method 'method', 'rb_cObject', 'm', 'rb_m', -1
+
+    m = @top_level.find_module_named('Object').method_list.first
+
+    assert_equal 'm', m.name
+    assert_equal @top_level, m.file
+    assert_equal 115, m.offset
+    assert_equal 7, m.line
+
+    assert_equal '(p1)', m.params
+  end
+
+  def test_handle_method_args_0
+    parser = util_parser "Document-method: BasicObject#==\n blah */"
+
+    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', 0
+
+    bo = @top_level.find_module_named 'BasicObject'
+
+    assert_equal 1, bo.method_list.length
+
+    equals2 = bo.method_list.first
+
+    assert_equal '()', equals2.params
+  end
+
+  def test_handle_method_args_1
+    parser = util_parser "Document-method: BasicObject#==\n blah */"
+
+    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', 1
+
+    bo = @top_level.find_module_named 'BasicObject'
+
+    assert_equal 1, bo.method_list.length
+
+    equals2 = bo.method_list.first
+
+    assert_equal '(p1)', equals2.params
+  end
+
+  def test_handle_method_args_2
+    parser = util_parser "Document-method: BasicObject#==\n blah */"
+
+    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', 2
+
+    bo = @top_level.find_module_named 'BasicObject'
+
+    assert_equal 1, bo.method_list.length
+
+    equals2 = bo.method_list.first
+
+    assert_equal '(p1, p2)', equals2.params
+  end
+
+  # test_handle_args_minus_1 handled by test_handle_method
+
+  def test_handle_method_args_minus_2
+    parser = util_parser "Document-method: BasicObject#==\n blah */"
+
+    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', -2
+
+    bo = @top_level.find_module_named 'BasicObject'
+
+    assert_equal 1, bo.method_list.length
+
+    equals2 = bo.method_list.first
+
+    assert_equal '(*args)', equals2.params
+  end
+
+  def test_handle_method_initialize
+    parser = util_parser "Document-method: BasicObject::new\n blah */"
+
+    parser.handle_method('private_method', 'rb_cBasicObject',
+                         'initialize', 'rb_obj_dummy', -1)
+
+    bo = @top_level.find_module_named 'BasicObject'
+
+    assert_equal 1, bo.method_list.length
+
+    new = bo.method_list.first
+
+    assert_equal 'new',   new.name
+    assert_equal :public, new.visibility
+  end
+
+  def test_handle_singleton
+    parser = util_parser <<-SINGLE
+void Init_Blah(void) {
+  cDate = rb_define_class("Date", rb_cObject);
+  sDate = rb_singleton_class(cDate);
+}
+    SINGLE
+
+    parser.scan
+
+    assert_equal 'Date', parser.known_classes['sDate']
+    assert_equal 'Date', parser.singleton_classes['sDate']
+  end
+
+  def test_look_for_directives_in
+    parser = util_parser ''
+
+    comment = RDoc::Comment.new "# :other: not_handled\n"
+
+    parser.look_for_directives_in @top_level, comment
+
+    assert_equal "# :other: not_handled\n", comment.text
+    assert_equal 'not_handled', @top_level.metadata['other']
+  end
+
+  def test_define_method
+    content = <<-EOF
+/*Method Comment! */
+static VALUE
+rb_io_s_read(argc, argv, io)
+    int argc;
+    VALUE *argv;
+    VALUE io;
+{
+}
+
+void
+Init_IO(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
+    rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1);
+}
+    EOF
+
+    klass = util_get_class content, 'rb_cIO'
+    read_method = klass.method_list.first
+    assert_equal "read", read_method.name
+    assert_equal "Method Comment!   ", read_method.comment.text
+    assert_equal "rb_io_s_read", read_method.c_function
+    assert read_method.singleton
+  end
+
+  def test_define_method_with_prototype
+    content = <<-EOF
+static VALUE rb_io_s_read(int, VALUE*, VALUE);
+
+/* Method Comment! */
+static VALUE
+rb_io_s_read(argc, argv, io)
+    int argc;
+    VALUE *argv;
+    VALUE io;
+{
+}
+
+void
+Init_IO(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
+    rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1);
+}
+    EOF
+
+    klass = util_get_class content, 'rb_cIO'
+    read_method = klass.method_list.first
+    assert_equal "read", read_method.name
+    assert_equal "Method Comment!   ", read_method.comment.text
+    assert_equal "rb_io_s_read", read_method.c_function
+    assert read_method.singleton
+  end
+
+  def test_define_method_private
+    content = <<-EOF
+/*Method Comment! */
+static VALUE
+rb_io_s_read(argc, argv, io)
+    int argc;
+    VALUE *argv;
+    VALUE io;
+{
+}
+
+void
+Init_IO(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
+    rb_define_private_method(rb_cIO, "read", rb_io_s_read, -1);
+}
+    EOF
+
+    klass = util_get_class content, 'rb_cIO'
+    read_method = klass.method_list.first
+    assert_equal 'IO#read', read_method.full_name
+    assert_equal :private, read_method.visibility
+    assert_equal "Method Comment!   ", read_method.comment.text
+  end
+
+  def test_define_method_private_singleton
+    content = <<-EOF
+/*Method Comment! */
+static VALUE
+rb_io_s_read(argc, argv, io)
+    int argc;
+    VALUE *argv;
+    VALUE io;
+{
+}
+
+void
+Init_IO(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
+    VALUE rb_cIO_s = rb_singleton_class(rb_cIO);
+    rb_define_private_method(rb_cIO_s, "read", rb_io_s_read, -1);
+}
+    EOF
+
+    klass = util_get_class content, 'rb_cIO'
+    read_method = klass.method_list.first
+    assert_equal "read", read_method.name
+    assert_equal "Method Comment!   ", read_method.comment.text
+    assert_equal :private, read_method.visibility
+    assert read_method.singleton
+  end
+
+  def test_define_method_singleton
+    content = <<-EOF
+/*Method Comment! */
+static VALUE
+rb_io_s_read(argc, argv, io)
+    int argc;
+    VALUE *argv;
+    VALUE io;
+{
+}
+
+void
+Init_IO(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
+    VALUE rb_cIO_s = rb_singleton_class(rb_cIO);
+    rb_define_method(rb_cIO_s, "read", rb_io_s_read, -1);
+}
+    EOF
+
+    klass = util_get_class content, 'rb_cIO'
+    read_method = klass.method_list.first
+    assert_equal "read", read_method.name
+    assert_equal "Method Comment!   ", read_method.comment.text
+    assert read_method.singleton
+  end
+
+  def test_rb_scan_args
+    parser = util_parser ''
+
+    assert_equal '(p1)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "1",)')
+    assert_equal '(p1, p2)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "2",)')
+
+    assert_equal '(p1 = v1)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "01",)')
+    assert_equal '(p1 = v1, p2 = v2)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "02",)')
+
+    assert_equal '(p1, p2 = v2)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "11",)')
+
+    assert_equal '(p1, *args)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "1*",)')
+    assert_equal '(p1, p2 = {})',
+                 parser.rb_scan_args('rb_scan_args(a, b, "1:",)')
+    assert_equal '(p1, &block)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "1&",)')
+
+    assert_equal '(p1, p2)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "101",)')
+
+    assert_equal '(p1, p2 = v2, p3)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "111",)')
+
+    assert_equal '(p1, *args, p3)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "1*1",)')
+
+    assert_equal '(p1, p2 = v2, *args)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "11*",)')
+    assert_equal '(p1, p2 = v2, p3 = {})',
+                 parser.rb_scan_args('rb_scan_args(a, b, "11:",)')
+    assert_equal '(p1, p2 = v2, &block)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "11&",)')
+
+    assert_equal '(p1, p2 = v2, *args, p4, p5 = {}, &block)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "11*1:&",)')
+
+    # The following aren't valid according to spec but are according to the
+    # implementation.
+    assert_equal '(*args)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "*",)')
+    assert_equal '(p1 = {})',
+                 parser.rb_scan_args('rb_scan_args(a, b, ":",)')
+    assert_equal '(&block)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "&",)')
+
+    assert_equal '(*args, p2 = {})',
+                 parser.rb_scan_args('rb_scan_args(a, b, "*:",)')
+    assert_equal '(p1 = {}, &block)',
+                 parser.rb_scan_args('rb_scan_args(a, b, ":&",)')
+    assert_equal '(*args, p2 = {}, &block)',
+                 parser.rb_scan_args('rb_scan_args(a, b, "*:&",)')
+  end
+
+  def util_get_class(content, name)
+    @parser = util_parser content
+    @parser.scan
+    @parser.classes[name]
+  end
+
+  def util_parser(content)
+    RDoc::Parser::C.new @top_level, @fn, content, @options, @stats
+  end
+
+end
+