JezK

Name: test
Start: 2022-11-25
End: 2022-11-25

Edit File: test_rdoc_parser_c.rb

require 'stringio'
require 'tempfile'
require 'rubygems'
require 'minitest/autorun'
require 'rdoc/options'
require 'rdoc/parser/c'

=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 < MiniTest::Unit::TestCase

def setup
    @tempfile = Tempfile.new self.class.name
    filename = @tempfile.path

@top_level = RDoc::TopLevel.new filename
    @fn = filename
    @options = RDoc::Options.new
    @stats = RDoc::Stats.new 0

RDoc::Parser::C.reset
    RDoc::TopLevel.reset
  end

def teardown
    @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
    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

writer = attrs.shift
    assert_equal 'writer',           writer.name
    assert_equal 'W',                writer.rw
    assert_equal 'This is a writer', writer.comment
  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

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
  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
    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
    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
  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
  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
 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
  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
  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] }

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
  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
    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

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
  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