yard 0.9.16 → 0.9.17

data/spec/options_spec.rb

@@ -1,171 +1,171 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Options do
-  class FooOptions < YARD::Options
-    attr_accessor :foo
-    def initialize; self.foo = "abc" end
-  end
-
-  describe ".default_attr" do
-    it "allows default attributes to be defined with symbols" do
-      class DefaultOptions1 < YARD::Options
-        default_attr :foo, 'HELLO'
-      end
-      o = DefaultOptions1.new
-      o.reset_defaults
-      expect(o.foo).to eq 'HELLO'
-    end
-
-    it "calls lambda if value is a Proc" do
-      class DefaultOptions2 < YARD::Options
-        default_attr :foo, lambda { 100 }
-      end
-      o = DefaultOptions2.new
-      o.reset_defaults
-      expect(o.foo).to eq 100
-    end
-  end
-
-  describe "#reset_defaults" do
-    it "does not define defaults until reset is called" do
-      class ResetDefaultOptions1 < YARD::Options
-        default_attr :foo, 'FOO'
-      end
-      expect(ResetDefaultOptions1.new.foo).to be nil
-      o = ResetDefaultOptions1.new
-      o.reset_defaults
-      expect(o.foo).to eq 'FOO'
-    end
-
-    it "uses defaults from superclass as well" do
-      class ResetDefaultOptions2 < YARD::Options
-        default_attr :foo, 'FOO'
-      end
-      class ResetDefaultOptions3 < ResetDefaultOptions2
-      end
-      o = ResetDefaultOptions3.new
-      o.reset_defaults
-      expect(o.foo).to eq 'FOO'
-    end
-  end
-
-  describe "#delete" do
-    it "deletes an option" do
-      o = FooOptions.new
-      o.delete(:foo)
-      expect(o.to_hash).to eq({})
-    end
-
-    it "does not error if an option is deleted that does not exist" do
-      o = FooOptions.new
-      o.delete(:foo)
-      o.delete(:foo)
-      expect(o.to_hash).to eq({})
-    end
-  end
-
-  describe "#[]" do
-    it "handles getting option values using hash syntax" do
-      expect(FooOptions.new[:foo]).to eq "abc"
-    end
-  end
-
-  describe "#[]=" do
-    it "handles setting options using hash syntax" do
-      o = FooOptions.new
-      o[:foo] = "xyz"
-      expect(o[:foo]).to eq "xyz"
-    end
-
-    it "allows setting of unregistered keys" do
-      o = FooOptions.new
-      o[:bar] = "foo"
-      expect(o[:bar]).to eq "foo"
-    end
-  end
-
-  describe "#method_missing" do
-    it "allows setting of unregistered keys" do
-      o = FooOptions.new
-      o.bar = 'foo'
-      expect(o.bar).to eq 'foo'
-    end
-
-    it "allows getting values of unregistered keys (return nil)" do
-      expect(FooOptions.new.bar).to be nil
-    end
-
-    it "prints debugging messages about unregistered keys" do
-      expect(log).to receive(:debug).with("Attempting to access unregistered key bar on FooOptions")
-      FooOptions.new.bar
-      expect(log).to receive(:debug).with("Attempting to set unregistered key bar on FooOptions")
-      FooOptions.new.bar = 1
-    end
-  end
-
-  describe "#update" do
-    it "allows updating of options" do
-      expect(FooOptions.new.update(:foo => "xyz").foo).to eq "xyz"
-    end
-
-    it "does not ignore keys with no setter (OpenStruct behaviour)" do
-      o = FooOptions.new
-      o.update(:bar => "xyz")
-      expect(o.to_hash).to eq(:foo => "abc", :bar => "xyz")
-    end
-  end
-
-  describe "#merge" do
-    it "updates a new object" do
-      o = FooOptions.new
-      expect(o.merge(:foo => "xyz").object_id).not_to eq o.object_id
-      expect(o.merge(:foo => "xyz").to_hash).to eq(:foo => "xyz")
-    end
-
-    it "adds in values from original object" do
-      o = FooOptions.new
-      o.update(:bar => "foo")
-      expect(o.merge(:baz => 1).to_hash).to eq(:foo => "abc", :bar => "foo", :baz => 1)
-    end
-  end
-
-  describe "#to_hash" do
-    it "converts all instance variables and symbolized keys" do
-      class ToHashOptions1 < YARD::Options
-        attr_accessor :foo, :bar, :baz
-        def initialize; @foo = 1; @bar = 2; @baz = "hello" end
-      end
-      o = ToHashOptions1.new
-      hash = o.to_hash
-      expect(hash.keys).to include(:foo, :bar, :baz)
-      expect(hash[:foo]).to eq 1
-      expect(hash[:bar]).to eq 2
-      expect(hash[:baz]).to eq "hello"
-    end
-
-    it "uses accessor when converting values to hash" do
-      class ToHashOptions2 < YARD::Options
-        def initialize; @foo = 1 end
-        def foo; "HELLO#{@foo}" end
-      end
-      o = ToHashOptions2.new
-      expect(o.to_hash).to eq(:foo => "HELLO1")
-    end
-
-    it "ignores ivars with no accessor" do
-      class ToHashOptions3 < YARD::Options
-        attr_accessor :foo
-        def initialize; @foo = 1; @bar = "NOIGNORE" end
-      end
-      o = ToHashOptions3.new
-      expect(o.to_hash).to eq(:foo => 1, :bar => "NOIGNORE")
-    end
-  end
-
-  describe "#tap" do
-    it "supports #tap(&block) (even in 1.8.6)" do
-      o = FooOptions.new.tap {|obj| obj.foo = :BAR }
-      expect(o.to_hash).to eq(:foo => :BAR)
-    end
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Options do
+  class FooOptions < YARD::Options
+    attr_accessor :foo
+    def initialize; self.foo = "abc" end
+  end
+
+  describe ".default_attr" do
+    it "allows default attributes to be defined with symbols" do
+      class DefaultOptions1 < YARD::Options
+        default_attr :foo, 'HELLO'
+      end
+      o = DefaultOptions1.new
+      o.reset_defaults
+      expect(o.foo).to eq 'HELLO'
+    end
+
+    it "calls lambda if value is a Proc" do
+      class DefaultOptions2 < YARD::Options
+        default_attr :foo, lambda { 100 }
+      end
+      o = DefaultOptions2.new
+      o.reset_defaults
+      expect(o.foo).to eq 100
+    end
+  end
+
+  describe "#reset_defaults" do
+    it "does not define defaults until reset is called" do
+      class ResetDefaultOptions1 < YARD::Options
+        default_attr :foo, 'FOO'
+      end
+      expect(ResetDefaultOptions1.new.foo).to be nil
+      o = ResetDefaultOptions1.new
+      o.reset_defaults
+      expect(o.foo).to eq 'FOO'
+    end
+
+    it "uses defaults from superclass as well" do
+      class ResetDefaultOptions2 < YARD::Options
+        default_attr :foo, 'FOO'
+      end
+      class ResetDefaultOptions3 < ResetDefaultOptions2
+      end
+      o = ResetDefaultOptions3.new
+      o.reset_defaults
+      expect(o.foo).to eq 'FOO'
+    end
+  end
+
+  describe "#delete" do
+    it "deletes an option" do
+      o = FooOptions.new
+      o.delete(:foo)
+      expect(o.to_hash).to eq({})
+    end
+
+    it "does not error if an option is deleted that does not exist" do
+      o = FooOptions.new
+      o.delete(:foo)
+      o.delete(:foo)
+      expect(o.to_hash).to eq({})
+    end
+  end
+
+  describe "#[]" do
+    it "handles getting option values using hash syntax" do
+      expect(FooOptions.new[:foo]).to eq "abc"
+    end
+  end
+
+  describe "#[]=" do
+    it "handles setting options using hash syntax" do
+      o = FooOptions.new
+      o[:foo] = "xyz"
+      expect(o[:foo]).to eq "xyz"
+    end
+
+    it "allows setting of unregistered keys" do
+      o = FooOptions.new
+      o[:bar] = "foo"
+      expect(o[:bar]).to eq "foo"
+    end
+  end
+
+  describe "#method_missing" do
+    it "allows setting of unregistered keys" do
+      o = FooOptions.new
+      o.bar = 'foo'
+      expect(o.bar).to eq 'foo'
+    end
+
+    it "allows getting values of unregistered keys (return nil)" do
+      expect(FooOptions.new.bar).to be nil
+    end
+
+    it "prints debugging messages about unregistered keys" do
+      expect(log).to receive(:debug).with("Attempting to access unregistered key bar on FooOptions")
+      FooOptions.new.bar
+      expect(log).to receive(:debug).with("Attempting to set unregistered key bar on FooOptions")
+      FooOptions.new.bar = 1
+    end
+  end
+
+  describe "#update" do
+    it "allows updating of options" do
+      expect(FooOptions.new.update(:foo => "xyz").foo).to eq "xyz"
+    end
+
+    it "does not ignore keys with no setter (OpenStruct behaviour)" do
+      o = FooOptions.new
+      o.update(:bar => "xyz")
+      expect(o.to_hash).to eq(:foo => "abc", :bar => "xyz")
+    end
+  end
+
+  describe "#merge" do
+    it "updates a new object" do
+      o = FooOptions.new
+      expect(o.merge(:foo => "xyz").object_id).not_to eq o.object_id
+      expect(o.merge(:foo => "xyz").to_hash).to eq(:foo => "xyz")
+    end
+
+    it "adds in values from original object" do
+      o = FooOptions.new
+      o.update(:bar => "foo")
+      expect(o.merge(:baz => 1).to_hash).to eq(:foo => "abc", :bar => "foo", :baz => 1)
+    end
+  end
+
+  describe "#to_hash" do
+    it "converts all instance variables and symbolized keys" do
+      class ToHashOptions1 < YARD::Options
+        attr_accessor :foo, :bar, :baz
+        def initialize; @foo = 1; @bar = 2; @baz = "hello" end
+      end
+      o = ToHashOptions1.new
+      hash = o.to_hash
+      expect(hash.keys).to include(:foo, :bar, :baz)
+      expect(hash[:foo]).to eq 1
+      expect(hash[:bar]).to eq 2
+      expect(hash[:baz]).to eq "hello"
+    end
+
+    it "uses accessor when converting values to hash" do
+      class ToHashOptions2 < YARD::Options
+        def initialize; @foo = 1 end
+        def foo; "HELLO#{@foo}" end
+      end
+      o = ToHashOptions2.new
+      expect(o.to_hash).to eq(:foo => "HELLO1")
+    end
+
+    it "ignores ivars with no accessor" do
+      class ToHashOptions3 < YARD::Options
+        attr_accessor :foo
+        def initialize; @foo = 1; @bar = "NOIGNORE" end
+      end
+      o = ToHashOptions3.new
+      expect(o.to_hash).to eq(:foo => 1, :bar => "NOIGNORE")
+    end
+  end
+
+  describe "#tap" do
+    it "supports #tap(&block) (even in 1.8.6)" do
+      o = FooOptions.new.tap {|obj| obj.foo = :BAR }
+      expect(o.to_hash).to eq(:foo => :BAR)
+    end
+  end
+end

data/spec/parser/base_spec.rb

@@ -1,24 +1,24 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Parser::Base do
-  describe "#initialize" do
-    class MyParser < Parser::Base; def initialize(a, b) end end
-
-    it "takes 2 arguments" do
-      expect { YARD::Parser::Base.new }.to raise_error(ArgumentError,
-        /wrong (number|#) of arguments|given 0, expected 2/)
-    end
-
-    it "raises NotImplementedError on #initialize" do
-      expect { YARD::Parser::Base.new('a', 'b') }.to raise_error(NotImplementedError)
-    end
-
-    it "raises NotImplementedError on #parse" do
-      expect { MyParser.new('a', 'b').parse }.to raise_error(NotImplementedError)
-    end
-
-    it "raises NotImplementedError on #tokenize" do
-      expect { MyParser.new('a', 'b').tokenize }.to raise_error(NotImplementedError)
-    end
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Parser::Base do
+  describe "#initialize" do
+    class MyParser < Parser::Base; def initialize(a, b) end end
+
+    it "takes 2 arguments" do
+      expect { YARD::Parser::Base.new }.to raise_error(ArgumentError,
+        /wrong (number|#) of arguments|given 0, expected 2/)
+    end
+
+    it "raises NotImplementedError on #initialize" do
+      expect { YARD::Parser::Base.new('a', 'b') }.to raise_error(NotImplementedError)
+    end
+
+    it "raises NotImplementedError on #parse" do
+      expect { MyParser.new('a', 'b').parse }.to raise_error(NotImplementedError)
+    end
+
+    it "raises NotImplementedError on #tokenize" do
+      expect { MyParser.new('a', 'b').tokenize }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/parser/c_parser_spec.rb

@@ -1,223 +1,236 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Parser::C::CParser do
-  describe "#parse" do
-    def parse(contents)
-      Registry.clear
-      YARD.parse_string(contents, :c)
-    end
-
-    describe "Array class" do
-      before(:all) do
-        file = File.join(File.dirname(__FILE__), 'examples', 'array.c.txt')
-        parse(File.read(file))
-      end
-
-      it "parses Array class" do
-        obj = YARD::Registry.at('Array')
-        expect(obj).not_to be nil
-        expect(obj.docstring).not_to be_blank
-      end
-
-      it "parses method" do
-        obj = YARD::Registry.at('Array#initialize')
-        expect(obj.docstring).not_to be_blank
-        expect(obj.tags(:overload).size).to be > 1
-      end
-
-      it "parses new_ary return type" do
-        obj = YARD::Registry.at('Array#map')
-        expect(obj.tags(:overload).count do |overload|
-          overload.tag(:return) && overload.tag(:return).types == ['Enumerator']
-        end).to eq 2
-        expect(obj.tags(:overload).count do |overload|
-          overload.tag(:return) && overload.tag(:return).types == ['Array']
-        end).to eq 2
-      end
-    end
-
-    describe "C++ namespace" do
-      before(:all) do
-        file = File.join(File.dirname(__FILE__), 'examples', 'namespace.cpp.txt')
-        parse(File.read(file))
-      end
-
-      it "parses Rect class" do
-        obj = YARD::Registry.at('Rect')
-        expect(obj).not_to be nil
-        expect(obj.docstring).not_to be_blank
-      end
-
-      it "parses method inside of namespace" do
-        obj = YARD::Registry.at('Rect#inspect')
-        expect(obj.docstring).not_to be_blank
-      end
-
-      it "parses method after namespace" do
-        obj = YARD::Registry.at('Rect#hello_world')
-        expect(obj.docstring).not_to be_blank
-      end
-    end
-
-    describe "Source located in extra files" do
-      before(:all) do
-        @multifile = File.join(File.dirname(__FILE__), 'examples', 'multifile.c.txt')
-        @extrafile = File.join(File.dirname(__FILE__), 'examples', 'extrafile.c.txt')
-        @contents = File.read(@multifile)
-      end
-
-      it "looks for methods in extra files (if 'in' comment is found)" do
-        extra_contents = File.read(@extrafile)
-        expect(File).to receive(:read).with('extra.c').and_return(extra_contents)
-        parse(@contents)
-        expect(Registry.at('Multifile#extra').docstring).to eq 'foo'
-      end
-
-      it "stops searching for extra source file gracefully if file is not found" do
-        expect(File).to receive(:read).with('extra.c').and_raise(Errno::ENOENT)
-        expect(log).to receive(:warn).with("Missing source file `extra.c' when parsing Multifile#extra")
-        parse(@contents)
-        expect(Registry.at('Multifile#extra').docstring).to eq ''
-      end
-
-      it "differentiates between a struct and a pointer to a struct retval" do
-        parse(@contents)
-        expect(Registry.at('Multifile#hello_mars').docstring).to eq 'Hello Mars'
-      end
-    end
-
-    describe "Foo class" do
-      it "does not include comments in docstring source" do
-        parse <<-eof
-          /*
-           * Hello world
-           */
-          VALUE foo(VALUE x) {
-            int value = x;
-          }
-
-          void Init_Foo() {
-            rb_define_method(rb_cFoo, "foo", foo, 1);
-          }
-        eof
-        expect(Registry.at('Foo#foo').source.gsub(/\s\s+/, ' ')).to eq(
-          "VALUE foo(VALUE x) { int value = x;\n}"
-        )
-      end
-    end
-
-    describe "Constant" do
-      it "does not truncate docstring" do
-        parse <<-eof
-          #define MSK_DEADBEEF 0xdeadbeef
-          void
-          Init_Mask(void)
-          {
-              rb_cMask  = rb_define_class("Mask", rb_cObject);
-              /* 0xdeadbeef: This constant is frequently used to indicate a
-               * software crash or deadlock in embedded systems. */
-              rb_define_const(rb_cMask, "DEADBEEF", INT2FIX(MSK_DEADBEEF));
-          }
-        eof
-        constant = Registry.at('Mask::DEADBEEF')
-        expect(constant.value).to eq '0xdeadbeef'
-        expect(constant.docstring).to eq "This constant is frequently used to indicate a\nsoftware crash or deadlock in embedded systems."
-      end
-    end
-
-    describe "Macros" do
-      it "handles param## inside of macros" do
-        thr = Thread.new do
-          parse <<-eof
-          void
-          Init_gobject_gparamspecs(void)
-          {
-              VALUE cParamSpec = GTYPE2CLASS(G_TYPE_PARAM);
-              VALUE c;
-
-          #define DEF_NUMERIC_PSPEC_METHODS(c, typename) \
-            G_STMT_START {\
-              rbg_define_method(c, "initialize", typename##_initialize, 7); \
-              rbg_define_method(c, "minimum", typename##_minimum, 0); \
-              rbg_define_method(c, "maximum", typename##_maximum, 0); \
-              rbg_define_method(c, "range", typename##_range, 0); \
-            } G_STMT_END
-
-          #if 0
-              rbg_define_method(c, "default_value", typename##_default_value, 0); \
-              rb_define_alias(c, "default", "default_value"); \
-
-          #endif
-
-              c = G_DEF_CLASS(G_TYPE_PARAM_CHAR, "Char", cParamSpec);
-              DEF_NUMERIC_PSPEC_METHODS(c, char);
-          eof
-        end
-        thr.join(5)
-        if thr.alive?
-          thr.kill
-          raise "Did not parse in time"
-        end
-      end
-    end
-
-    describe "C macros in declaration" do
-      it "handles C macros in method declaration" do
-        Registry.clear
-        parse <<-eof
-        // docstring
-        FOOBAR VALUE func() { }
-
-        void
-        Init_mod(void)
-        {
-          rb_define_method(rb_cFoo, "func", func, 0); \
-        }
-        eof
-
-        expect(Registry.at('Foo#func').docstring).to eq "docstring"
-      end
-    end
-  end
-
-  describe "Override comments" do
-    before(:all) do
-      Registry.clear
-      override_file = File.join(File.dirname(__FILE__), 'examples', 'override.c.txt')
-      @override_parser = YARD.parse_string(File.read(override_file), :c)
-    end
-
-    it "parses GMP::Z class" do
-      z = YARD::Registry.at('GMP::Z')
-      expect(z).not_to be nil
-      expect(z.docstring).not_to be_blank
-    end
-
-    it "parses GMP::Z methods w/ bodies" do
-      add = YARD::Registry.at('GMP::Z#+')
-      expect(add.docstring).not_to be_blank
-      expect(add.source).not_to be nil
-      expect(add.source).not_to be_empty
-
-      add_self = YARD::Registry.at('GMP::Z#+')
-      expect(add_self.docstring).not_to be_blank
-      expect(add_self.source).not_to be nil
-      expect(add_self.source).not_to be_empty
-
-      sqrtrem = YARD::Registry.at('GMP::Z#+')
-      expect(sqrtrem.docstring).not_to be_blank
-      expect(sqrtrem.source).not_to be nil
-      expect(sqrtrem.source).not_to be_empty
-    end
-
-    it "parses GMP::Z methods w/o bodies" do
-      neg = YARD::Registry.at('GMP::Z#neg')
-      expect(neg.docstring).not_to be_blank
-      expect(neg.source).to be nil
-
-      neg_self = YARD::Registry.at('GMP::Z#neg')
-      expect(neg_self.docstring).not_to be_blank
-      expect(neg_self.source).to be nil
-    end
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Parser::C::CParser do
+  describe "#parse" do
+    def parse(contents)
+      Registry.clear
+      YARD.parse_string(contents, :c)
+    end
+
+    describe "Array class" do
+      before(:all) do
+        file = File.join(File.dirname(__FILE__), 'examples', 'array.c.txt')
+        parse(File.read(file))
+      end
+
+      it "parses Array class" do
+        obj = YARD::Registry.at('Array')
+        expect(obj).not_to be nil
+        expect(obj.docstring).not_to be_blank
+      end
+
+      it "parses method" do
+        obj = YARD::Registry.at('Array#initialize')
+        expect(obj.docstring).not_to be_blank
+        expect(obj.tags(:overload).size).to be > 1
+      end
+
+      it "parses new_ary return type" do
+        obj = YARD::Registry.at('Array#map')
+        expect(obj.tags(:overload).count do |overload|
+          overload.tag(:return) && overload.tag(:return).types == ['Enumerator']
+        end).to eq 2
+        expect(obj.tags(:overload).count do |overload|
+          overload.tag(:return) && overload.tag(:return).types == ['Array']
+        end).to eq 2
+      end
+    end
+
+    describe "C++ namespace" do
+      before(:all) do
+        file = File.join(File.dirname(__FILE__), 'examples', 'namespace.cpp.txt')
+        parse(File.read(file))
+      end
+
+      it "parses Rect class" do
+        obj = YARD::Registry.at('Rect')
+        expect(obj).not_to be nil
+        expect(obj.docstring).not_to be_blank
+      end
+
+      it "parses method inside of namespace" do
+        obj = YARD::Registry.at('Rect#inspect')
+        expect(obj.docstring).not_to be_blank
+      end
+
+      it "parses method after namespace" do
+        obj = YARD::Registry.at('Rect#hello_world')
+        expect(obj.docstring).not_to be_blank
+      end
+    end
+
+    describe "Source located in extra files" do
+      before(:all) do
+        @multifile = File.join(File.dirname(__FILE__), 'examples', 'multifile.c.txt')
+        @extrafile = File.join(File.dirname(__FILE__), 'examples', 'extrafile.c.txt')
+        @contents = File.read(@multifile)
+      end
+
+      it "looks for methods in extra files (if 'in' comment is found)" do
+        extra_contents = File.read(@extrafile)
+        expect(File).to receive(:read).with('extra.c').and_return(extra_contents)
+        parse(@contents)
+        expect(Registry.at('Multifile#extra').docstring).to eq 'foo'
+      end
+
+      it "stops searching for extra source file gracefully if file is not found" do
+        expect(File).to receive(:read).with('extra.c').and_raise(Errno::ENOENT)
+        expect(log).to receive(:warn).with("Missing source file `extra.c' when parsing Multifile#extra")
+        parse(@contents)
+        expect(Registry.at('Multifile#extra').docstring).to eq ''
+      end
+
+      it "differentiates between a struct and a pointer to a struct retval" do
+        parse(@contents)
+        expect(Registry.at('Multifile#hello_mars').docstring).to eq 'Hello Mars'
+      end
+    end
+
+    describe "Foo class" do
+      it "does not include comments in docstring source" do
+        parse <<-eof
+          /*
+           * Hello world
+           */
+          VALUE foo(VALUE x) {
+            int value = x;
+          }
+
+          void Init_Foo() {
+            rb_define_method(rb_cFoo, "foo", foo, 1);
+          }
+        eof
+        expect(Registry.at('Foo#foo').source.gsub(/\s\s+/, ' ')).to eq(
+          "VALUE foo(VALUE x) { int value = x;\n}"
+        )
+      end
+    end
+
+    describe "Constant" do
+      it "does not truncate docstring" do
+        parse <<-eof
+          #define MSK_DEADBEEF 0xdeadbeef
+          void
+          Init_Mask(void)
+          {
+              rb_cMask  = rb_define_class("Mask", rb_cObject);
+              /* 0xdeadbeef: This constant is frequently used to indicate a
+               * software crash or deadlock in embedded systems. */
+              rb_define_const(rb_cMask, "DEADBEEF", INT2FIX(MSK_DEADBEEF));
+          }
+        eof
+        constant = Registry.at('Mask::DEADBEEF')
+        expect(constant.value).to eq '0xdeadbeef'
+        expect(constant.docstring).to eq "This constant is frequently used to indicate a\nsoftware crash or deadlock in embedded systems."
+      end
+    end
+
+    describe "Macros" do
+      it "handles param## inside of macros" do
+        thr = Thread.new do
+          parse <<-eof
+          void
+          Init_gobject_gparamspecs(void)
+          {
+              VALUE cParamSpec = GTYPE2CLASS(G_TYPE_PARAM);
+              VALUE c;
+
+          #define DEF_NUMERIC_PSPEC_METHODS(c, typename) \
+            G_STMT_START {\
+              rbg_define_method(c, "initialize", typename##_initialize, 7); \
+              rbg_define_method(c, "minimum", typename##_minimum, 0); \
+              rbg_define_method(c, "maximum", typename##_maximum, 0); \
+              rbg_define_method(c, "range", typename##_range, 0); \
+            } G_STMT_END
+
+          #if 0
+              rbg_define_method(c, "default_value", typename##_default_value, 0); \
+              rb_define_alias(c, "default", "default_value"); \
+
+          #endif
+
+              c = G_DEF_CLASS(G_TYPE_PARAM_CHAR, "Char", cParamSpec);
+              DEF_NUMERIC_PSPEC_METHODS(c, char);
+          eof
+        end
+        thr.join(5)
+        if thr.alive?
+          thr.kill
+          raise "Did not parse in time"
+        end
+      end
+    end
+
+    describe "C macros in declaration" do
+      it "handles C macros in method declaration" do
+        Registry.clear
+        parse <<-eof
+        // docstring
+        FOOBAR VALUE func() { }
+
+        void
+        Init_mod(void)
+        {
+          rb_define_method(rb_cFoo, "func", func, 0); \
+        }
+        eof
+
+        expect(Registry.at('Foo#func').docstring).to eq "docstring"
+      end
+    end
+
+    describe "File singleton methods" do
+      before(:all) do
+        file = File.join(File.dirname(__FILE__), 'examples', 'file.c.txt')
+        parse(File.read(file))
+      end
+
+      it "parses methods from define_filetest_function" do
+        obj = YARD::Registry.at('File.exist?')
+        expect(obj).not_to be nil
+        expect(obj.docstring).not_to be_blank
+      end
+    end
+  end
+
+  describe "Override comments" do
+    before(:all) do
+      Registry.clear
+      override_file = File.join(File.dirname(__FILE__), 'examples', 'override.c.txt')
+      @override_parser = YARD.parse_string(File.read(override_file), :c)
+    end
+
+    it "parses GMP::Z class" do
+      z = YARD::Registry.at('GMP::Z')
+      expect(z).not_to be nil
+      expect(z.docstring).not_to be_blank
+    end
+
+    it "parses GMP::Z methods w/ bodies" do
+      add = YARD::Registry.at('GMP::Z#+')
+      expect(add.docstring).not_to be_blank
+      expect(add.source).not_to be nil
+      expect(add.source).not_to be_empty
+
+      add_self = YARD::Registry.at('GMP::Z#+')
+      expect(add_self.docstring).not_to be_blank
+      expect(add_self.source).not_to be nil
+      expect(add_self.source).not_to be_empty
+
+      sqrtrem = YARD::Registry.at('GMP::Z#+')
+      expect(sqrtrem.docstring).not_to be_blank
+      expect(sqrtrem.source).not_to be nil
+      expect(sqrtrem.source).not_to be_empty
+    end
+
+    it "parses GMP::Z methods w/o bodies" do
+      neg = YARD::Registry.at('GMP::Z#neg')
+      expect(neg.docstring).not_to be_blank
+      expect(neg.source).to be nil
+
+      neg_self = YARD::Registry.at('GMP::Z#neg')
+      expect(neg_self.docstring).not_to be_blank
+      expect(neg_self.source).to be nil
+    end
+  end
+end