ffi-clang 0.3.0 → 0.5.0

data/spec/{clang → ffi/clang}/code_completion_spec.rb

@@ -18,14 +18,12 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'spec_helper'
-
 describe CodeCompletion do
 	let(:filename) { fixture_path("completion.cxx") }
-	let(:tu) { Index.new.parse_translation_unit(filename) }
+	let(:translation_unit) { Index.new.parse_translation_unit(filename) }
 	let(:line) { 7 }
 	let(:column) { 6 }
-	let(:results) { tu.code_complete(filename, line, column) }
+	let(:results) { translation_unit.code_complete(filename, line, column) }
 
 	describe "self.default_code_completion_options" do
 		let(:options) { FFI::Clang::CodeCompletion.default_code_completion_options }
@@ -101,8 +99,10 @@ describe CodeCompletion do
 		it "#sort!" do
 			results.sort!
 			
-			# may be sorted with typed_text kind, first result will start with 'a'
-			expect(results.results.first.string.chunks.select{|x| x[:kind] == :typed_text}.first[:text]).to be =~ /^a/
+			possibilities = results.first.string.chunks.select{|x| x[:kind] == :typed_text}.collect{|chunk| chunk[:text]}
+			
+			# may be sorted with typed_text kind, first result will start with 'a'.. not necessarily
+			expect(possibilities).to be == possibilities.sort
 		end
 	end
 

data/spec/{clang → ffi/clang}/comment_spec.rb

@@ -19,59 +19,56 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'spec_helper'
-
 describe Comment do
 	let(:cursor) { Index.new.parse_translation_unit(fixture_path("docs.cc")).cursor }
 	let (:comment) { find_first(cursor, :cursor_function).comment }
 
 	it "can be obtained from a cursor" do
-		comment.should be_kind_of(Comment)
-		comment.should be_kind_of(FullComment)
-		comment.kind.should equal(:comment_full)
+		expect(comment).to be_kind_of(Comment)
+		expect(comment).to be_kind_of(FullComment)
+		expect(comment.kind).to equal(:comment_full)
 	end
 
 	it "can parse the brief description" do
 		para = comment.child
-		para.kind.should equal(:comment_paragraph)
-		para.should be_kind_of(ParagraphComment)
+		expect(para.kind).to equal(:comment_paragraph)
+		expect(para).to be_kind_of(ParagraphComment)
 		text = para.child
-		text.kind.should equal(:comment_text)
-		text.should be_kind_of(TextComment)
-		text.text.strip.should eq("Short explanation")
+		expect(text.kind).to equal(:comment_text)
+		expect(text).to be_kind_of(TextComment)
+		expect(text.text.strip).to eq("Short explanation")
 	end
 
 	it "can parse the longer description" do
 		para = comment.child(1)
-		para.kind.should equal(:comment_paragraph)
-		para.num_children.should equal(2)
-		text = para.child
+		expect(para.kind).to equal(:comment_paragraph)
+		expect(para.num_children).to equal(2)
 
 		lines = (0..para.num_children-1).map do |i|
 			para.child(i).text
 		end
 
-		lines.should eq([" This is a longer explanation",
+		expect(lines).to eq([" This is a longer explanation",
 				 " that spans multiple lines"])
 	end
 
 	it "has working helpers" do
-		comment.num_children.should equal(8)
+		expect(comment.num_children).to equal(8)
 
 		para = comment.child(1)
-		para.text.should eq(" This is a longer explanation\n that spans multiple lines")
+		expect(para.text).to eq(" This is a longer explanation\n that spans multiple lines")
 	end
 
 	it "understands params" do
 		[['input', " some input\n "], ['flags', " some flags\n "]].each_with_index do |v, child_idx|
 			param = comment.child(3 + child_idx)
-			param.should be_kind_of(ParamCommandComment)
+			expect(param).to be_kind_of(ParamCommandComment)
 
-			param.valid_index?.should == true
-			param.index.should equal(child_idx)
-			param.name.should eq(v[0])
-			param.child.text.should eq v[1]
-			param.comment.should eq v[1]
+			expect(param.valid_index?).to be_truthy
+			expect(param.index).to be == child_idx
+			expect(param.name).to be == v[0]
+			expect(param.child.text).to be == v[1]
+			expect(param.comment).to be == v[1]
 		end
 	end
 
@@ -135,15 +132,10 @@ describe Comment do
 		end
 
 		describe "#text" do
-			it "returns HTML tag as string", from_3_4: true do
+			it "returns HTML tag as string" do
 				expect(html_start_tag_comments[0].text.strip).to eq('<br/>')
 				expect(html_start_tag_comments[1].text.strip).to eq('<a href="http://example.org/">')
 			end
-
-			it "returuns empty string", upto_3_3: true do
-				expect(html_start_tag_comments[0].text.strip).to eq('')
-				expect(html_start_tag_comments[1].text.strip).to eq('')
-			end
 		end
 
 		describe "#self_closing?" do
@@ -193,13 +185,9 @@ describe Comment do
 		end
 
 		describe "#text" do
-			it "returns HTML tag as string", from_3_4: true do
+			it "returns HTML tag as string" do
 				expect(html_end_tag_comment.text.strip).to eq('</a>')
 			end
-
-			it "returuns empty string", upto_3_3: true do
-				expect(html_end_tag_comment.text.strip).to eq('')
-			end
 		end
 	end
 
@@ -214,15 +202,10 @@ describe Comment do
 		end
 
 		describe "#to_html" do
-			it "converts a given full parsed comment to an HTML fragment", from_3_4: true do
+			it "converts a given full parsed comment to an HTML fragment" do
 				expect(comment.to_html).to be_kind_of(String)
 				expect(comment.to_html).to eq('<p class="para-brief"> this is a function.</p>')
 			end
-
-			it "converts a given full parsed comment to an HTML fragment", upto_3_3: true do
-				expect(comment.to_html).to be_kind_of(String)
-				expect(comment.to_html).to eq('<p class="para-brief"> this is a function. </p>')
-			end
 		end
 
 		describe "#to_xml" do

data/spec/{clang → ffi/clang}/compilation_database_spec.rb

@@ -18,8 +18,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'spec_helper'
-
 describe CompilationDatabase do
 	let(:dirpath) { fixture_path('') }
 	let(:cdb) { CompilationDatabase.new(dirpath) }
@@ -35,7 +33,7 @@ describe CompilationDatabase do
 
 	it "calls compilation_database_dispose on GC" do
 		cdb.autorelease = false
-		expect(Lib).to receive(:compilation_database_dispose).with(cdb).once
+		# expect(Lib).to receive(:compilation_database_dispose).with(cdb).once
 		expect{cdb.free}.not_to raise_error
 	end
 
@@ -53,7 +51,7 @@ describe CompilationDatabase do
 		end
 	end
 
-	describe '#all_compile_commands', from_3_3: true do
+	describe '#all_compile_commands' do
 		it "returns all compile commands in the database" do
 			expect(cdb.all_compile_commands).to be_kind_of(CompilationDatabase::CompileCommands)
 			expect(cdb.all_compile_commands.size).to eq(3)
@@ -65,7 +63,7 @@ describe CompilationDatabase do
 
 		it "calls compile_commands_dispose on GC" do
 			commands.autorelease = false
-			expect(Lib).to receive(:compile_commands_dispose).with(commands).once
+			# expect(Lib).to receive(:compile_commands_dispose).with(commands).once
 			expect{commands.free}.not_to raise_error
 		end
 
@@ -75,7 +73,7 @@ describe CompilationDatabase do
 				expect(commands.size).to eq(1)
 			end
 
-			it "returns the number of CompileCommand", from_3_3: true do
+			it "returns the number of CompileCommand" do
 				expect(cdb.all_compile_commands.size).to eq(3)
 			end
 		end
@@ -135,7 +133,7 @@ describe CompilationDatabase do
 			end
 		end
 
-		describe '#num_mapped_sources', from_3_4: true do
+		describe '#num_mapped_sources' do
 			# TODO: a case which has mapped sources
 
 			it "returns the number of source mappings" do
@@ -144,7 +142,7 @@ describe CompilationDatabase do
 			end
 		end
 
-		describe '#mapped_source_path', from_3_4: true do
+		describe '#mapped_source_path' do
 			it "returns the I'th mapped source path" do
 				# TODO: a case which returns real source path
 				# expect(cmd.mapped_source_path(0)).to be_kind_of(String)
@@ -155,7 +153,7 @@ describe CompilationDatabase do
 			end
 		end
 
-		describe '#mapped_source_content', from_3_4: true do
+		describe '#mapped_source_content' do
 			it "returns the I'th mapped source content" do
 				# TODO: a case which returns real source path
 				# expect(cmd.mapped_source_content(0)).to be_kind_of(String)
@@ -166,7 +164,7 @@ describe CompilationDatabase do
 			end
 		end
 
-		describe '#mapped_sources', from_3_4: true do
+		describe '#mapped_sources' do
 			# TODO: a case which has mapped sources
 
 			it "returns all mapped sources as Array" do

data/spec/{clang → ffi/clang}/cursor_spec.rb

@@ -2,14 +2,14 @@
 # Copyright, 2013, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # Copyright, 2013, by Garry C. Marshall. <http://www.meaningfulname.net>
 # Copyright, 2014, by Masahiro Sano.
-# 
+#
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
-# 
+#
 # The above copyright notice and this permission notice shall be included in
 # all copies or substantial portions of the Software.
 #
@@ -21,7 +21,20 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'spec_helper'
+describe "Function Call Cursors" do
+	let(:translation_unit) {Index.new.parse_translation_unit(fixture_path("class.cpp"))}
+	let(:cursor) {translation_unit.cursor}
+	let(:call) {find_first(cursor, :cursor_call_expr)}
+
+	it "should parse correctly" do
+		expect(translation_unit.diagnostics).to be_empty
+	end
+
+	it "should find a method call" do
+		call.should_not be_nil
+	end
+end
+
 
 describe Cursor do
 	let(:cursor) { Index.new.parse_translation_unit(fixture_path("list.c")).cursor }
@@ -30,15 +43,15 @@ describe Cursor do
 	let(:cursor_pp) { Index.new.parse_translation_unit(fixture_path("docs.c"),[],[],{detailed_preprocessing_record: true}).cursor }
 
 	it "can be obtained from a translation unit" do
-		cursor.should be_kind_of(Cursor)
-		cursor.kind.should equal(:cursor_translation_unit)
-		cursor.null?.should equal(false)
-		cursor.translation_unit?.should equal(true)
+		expect(cursor).to be_kind_of(Cursor)
+		expect(cursor.kind).to equal(:cursor_translation_unit)
+		expect(cursor.null?).to equal(false)
+		expect(cursor.translation_unit?).to equal(true)
 	end
 
 	it "returns the source location of the cursor" do
 		location = cursor.location
-		location.should be_kind_of(SourceLocation)
+		expect(location).to be_kind_of(SourceLocation)
 	end
 
 	describe '#extent' do
@@ -52,20 +65,15 @@ describe Cursor do
 			expect(extent.start.line).to equal(1)
 		end
 
-		it 'has filename and posion at end point', from_3_4: true do
+		it 'has filename and posion at end point' do
 			expect(extent.end.file).to eq(fixture_path("list.c"))
 			expect(extent.end.line).to equal(12)
 		end
-
-		it 'has filename and posion at end point', upto_3_3: true do
-			expect(extent.end.file).to eq(fixture_path("list.c"))
-			expect(extent.end.line).to equal(11)
-		end
 	end
 
 	it "returns the path of the translation unit for the translation unit cursor" do
-		cursor.display_name.should eq(fixture_path("list.c"))
-		cursor.spelling.should eq(fixture_path("list.c"))
+		expect(cursor.display_name).to eq(fixture_path("list.c"))
+		expect(cursor.spelling).to eq(fixture_path("list.c"))
 	end
 
 	it "allows us to visit its children" do
@@ -74,29 +82,29 @@ describe Cursor do
 			counter += 1
 			:recurse
 		end
-		counter.should_not equal(0)
+		expect(counter).not_to equal(0)
 	end
 
 	describe "Null Cursor" do
 		it "can be a null cursor" do
-			Cursor.null_cursor.should be_kind_of(Cursor)
-			Cursor.null_cursor.kind.should equal(:cursor_invalid_file)
+			expect(Cursor.null_cursor).to be_kind_of(Cursor)
+			expect(Cursor.null_cursor.kind).to equal(:cursor_invalid_file)
 		end
 
 		it "is null?" do
-			Cursor.null_cursor.null?.should equal(true)
+			expect(Cursor.null_cursor.null?).to equal(true)
 		end
 
 		it "is invalid?" do
-			Cursor.null_cursor.invalid?.should equal(true)
+			expect(Cursor.null_cursor.invalid?).to equal(true)
 		end
 
 		it "compares as equal to another null cursor instance" do
-			Cursor.null_cursor.should eq(Cursor.null_cursor)
+			expect(Cursor.null_cursor).to eq(Cursor.null_cursor)
 		end
 
 		it "should not equal a Translation Unit cursor" do
-			Cursor.null_cursor.should_not eq(cursor)
+			expect(Cursor.null_cursor).not_to eq(cursor)
 		end
 	end
 
@@ -104,23 +112,23 @@ describe Cursor do
 		let (:func) { find_first(cursor, :cursor_function) }
 
 		it "is not invalid?" do
-			func.invalid?.should equal(false)
+			expect(func.invalid?).to equal(false)
 		end
 
 		it "can find the first function declaration" do
-			func.should_not equal(nil)
-			func.kind.should equal(:cursor_function)
+			expect(func).not_to equal(nil)
+			expect(func.kind).to equal(:cursor_function)
 		end
 
 		it "has an extent representing the bounds of the function" do
-			func.extent.should be_kind_of(SourceRange)
-			func.extent.start.line.should equal(5)
-			func.extent.end.line.should equal(5)
+			expect(func.extent).to be_kind_of(SourceRange)
+			expect(func.extent.start.line).to equal(5)
+			expect(func.extent.end.line).to equal(5)
 		end
 
 		it "returns the name of the function" do
-			func.spelling.should eq("sum")
-			func.display_name.should eq("sum(union List *)")
+			expect(func.spelling).to eq("sum")
+			expect(func.display_name).to eq("sum(union List *)")
 		end
 	end
 
@@ -128,18 +136,18 @@ describe Cursor do
 		let (:struct) { find_first(cursor, :cursor_struct) }
 
 		it "can find the first struct" do
-			struct.should_not equal(nil)
-			struct.kind.should equal(:cursor_struct)
+			expect(struct).not_to equal(nil)
+			expect(struct.kind).to equal(:cursor_struct)
 		end
 
 		it "has an extent representing the bounds of the struct" do
-			struct.extent.start.line.should equal(1)
-			struct.extent.end.line.should equal(4)
+			expect(struct.extent.start.line).to equal(1)
+			expect(struct.extent.end.line).to equal(4)
 		end
 
 		it "returns the name of the struct" do
-			struct.spelling.should eq("List")
-			struct.display_name.should eq("List")
+			expect(struct.spelling).to eq("List")
+			expect(struct.display_name).to eq("List")
 		end
 
 	end
@@ -196,39 +204,27 @@ describe Cursor do
 		let(:public_cursor) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_field_decl and child.spelling == 'public_member_int' } }
 
-		it 'checks access control level is public', from_3_3: true do
+		it 'checks access control level is public' do
 			expect(public_cursor.public?).to be true
 		end
-
-		it 'returns false on clang 3.2', upto_3_2: true do
-			expect(public_cursor.public?).to be false
-		end
 	end
 
 	describe '#private?' do
 		let(:private_cursor) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_field_decl and child.spelling == 'private_member_int' } }
 
-		it 'checks access control level is private', from_3_3: true do
+		it 'checks access control level is private' do
 			expect(private_cursor.private?).to be true
 		end
-
-		it 'returns false on clang 3.2', upto_3_2: true do
-			expect(private_cursor.private?).to be false
-		end
 	end
 
 	describe '#protected?' do
 		let(:protected_cursor) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_field_decl and child.spelling == 'protected_member_int' } }
 
-		it 'checks access control level is protected', from_3_3: true do
+		it 'checks access control level is protected' do
 			expect(protected_cursor.protected?).to be true
 		end
-
-		it 'returns false on clang 3.2', upto_3_2: true do
-			expect(protected_cursor.protected?).to be false
-		end
 	end
 
 	describe '#preprocessing?' do
@@ -253,7 +249,7 @@ describe Cursor do
 				child.kind == :cursor_cxx_base_specifier and parent.spelling == 'B' } }
 
 		it 'checks cursor is virtual base' do
-			virtual_base_cursor.virtual_base?.should equal true
+			expect(virtual_base_cursor.virtual_base?).to equal true
 		end
 	end
 
@@ -262,17 +258,17 @@ describe Cursor do
 				child.kind == :cursor_cxx_method and child.spelling == 'func_a' } }
 
 		it 'checks member function is virtual' do
-			virtual_cursor.virtual?.should equal true
+			expect(virtual_cursor.virtual?).to equal true
 		end
 	end
 
-	describe '#pure_virtual?', from_3_4: true do
+	describe '#pure_virtual?' do
 		let(:pure_virtual_cursor) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_cxx_method and
 				child.spelling == 'func_a' and parent.spelling == 'A' } }
 
 		it 'checks member function is purely virtual' do
-			pure_virtual_cursor.pure_virtual?.should equal true
+			expect(pure_virtual_cursor.pure_virtual?).to equal true
 		end
 	end
 
@@ -281,7 +277,7 @@ describe Cursor do
 			child.kind == :cursor_cxx_method and child.spelling == 'func_b' } }
 
 		it 'checks cursor is static member function' do
-			static_method_cursor.static?.should equal true
+			expect(static_method_cursor.static?).to equal true
 		end
 	end
 
@@ -290,7 +286,7 @@ describe Cursor do
 			child.kind == :cursor_enum_constant_decl and child.spelling == 'EnumC' } }
 
 		it 'returns enum value' do
-			enum_value_cursor.enum_value.should equal 100
+			expect(enum_value_cursor.enum_value).to equal 100
 		end
 	end
 
@@ -305,7 +301,7 @@ describe Cursor do
 
 	describe '#dynamic_call?' do
 		let(:dynamic_call) { find_matching(cursor_cxx) { |child, parent|
-				child.kind == :cursor_call_expr and child.spelling == 'func_a' and 
+				child.kind == :cursor_call_expr and child.spelling == 'func_a' and
 				child.semantic_parent.spelling == 'f_dynamic_call' } }
 
 		it 'checks if the method call is dynamic' do
@@ -313,7 +309,7 @@ describe Cursor do
 		end
 	end
 
-	describe '#specialized_template', from_3_3: true do # looks not working on 3.2
+	describe '#specialized_template' do # looks not working on 3.2
 		let(:cursor_function) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_function and child.spelling == 'func_overloaded' } }
 
@@ -327,13 +323,13 @@ describe Cursor do
 		let (:structs) { find_all(cursor_canon, :cursor_struct) }
 
 		it "mathes 3 cursors" do
-			structs.size.should eq(3)
+			expect(structs.size).to eq(3)
 		end
 
 		it "refers the first cursor as canonical one" do
-			structs[0].canonical.should eq(structs[0])
-			structs[1].canonical.should eq(structs[0])
-			structs[2].canonical.should eq(structs[0])
+			expect(structs[0].canonical).to eq(structs[0])
+			expect(structs[1].canonical).to eq(structs[0])
+			expect(structs[2].canonical).to eq(structs[0])
 		end
 	end
 
@@ -341,17 +337,17 @@ describe Cursor do
 		let (:structs) { find_all(cursor_canon, :cursor_struct) }
 
 		it "mathes 3 cursors" do
-			structs.size.should eq(3)
+			expect(structs.size).to eq(3)
 		end
 
 		it "refers the third cursor as definition one" do
-			structs[0].definition.should eq(structs[2])
-			structs[1].definition.should eq(structs[2])
-			structs[2].definition.should eq(structs[2])
+			expect(structs[0].definition).to eq(structs[2])
+			expect(structs[1].definition).to eq(structs[2])
+			expect(structs[2].definition).to eq(structs[2])
 		end
 	end
 
-	describe '#template_kind', from_3_3: true do # looks not working on 3.2
+	describe '#template_kind' do # looks not working on 3.2
 		let(:template) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_function_template and child.spelling == 'func_overloaded' } }
 
@@ -365,12 +361,8 @@ describe Cursor do
 		let(:access_specifier_cursor) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_cxx_method and child.spelling == 'func_d' } }
 
-		it 'returns access specifier symbol', from_3_3: true do
-			access_specifier_cursor.access_specifier.should equal :private
-		end
-
-		it 'returns access specifier symbol(invalid, why?)', upto_3_2: true do
-			access_specifier_cursor.access_specifier.should equal :invalid
+		it 'returns access specifier symbol' do
+			expect(access_specifier_cursor.access_specifier).to equal :private
 		end
 	end
 
@@ -379,11 +371,11 @@ describe Cursor do
 		let(:cxx_language_cursor) { find_matching(cursor_cxx) { |c, p| c.kind == :cursor_struct } }
 
 		it 'returns :c if the cursor language is C' do
-			c_language_cursor.language.should equal :c
+			expect(c_language_cursor.language).to equal :c
 		end
 
 		it 'returns :c_plus_plus if the cursor language is C++' do
-			cxx_language_cursor.language.should equal :c_plus_plus
+			expect(cxx_language_cursor.language).to equal :c_plus_plus
 		end
 	end
 
@@ -391,12 +383,12 @@ describe Cursor do
 		let (:struct) { find_first(cursor, :cursor_struct) }
 
 		it "can find the first struct" do
-			struct.should_not equal(nil)
+			expect(struct).not_to equal(nil)
 		end
 
 		it "returns the translation unit that a cursor originated from" do
-			struct.translation_unit.should be_kind_of(TranslationUnit)
-			struct.translation_unit.spelling.should eq(fixture_path("list.c"))
+			expect(struct.translation_unit).to be_kind_of(TranslationUnit)
+			expect(struct.translation_unit.spelling).to eq(fixture_path("list.c"))
 		end
 	end
 
@@ -405,11 +397,11 @@ describe Cursor do
 		let (:func) { find_first(cursor, :cursor_function) }
 
 		it "returns :external if the cursor is non-static function" do
-			func.linkage.should equal :external
+			expect(func.linkage).to equal :external
 		end
 
 		it "returns :invalid if the cursor does not have linkage" do
-			ref.linkage.should equal :invalid
+			expect(ref.linkage).to equal :invalid
 		end
 	end
 
@@ -418,7 +410,7 @@ describe Cursor do
 				child.kind == :cursor_cxx_method and child.spelling == 'func_d' and parent.spelling != 'D' } }
 
 		it 'returns base class as semantic parent' do
-			parent.semantic_parent.spelling.should eq('D')
+			expect(parent.semantic_parent.spelling).to eq('D')
 		end
 	end
 
@@ -427,7 +419,7 @@ describe Cursor do
 				child.kind == :cursor_cxx_method and child.spelling == 'func_d' and parent.spelling != 'D' } }
 
 		it 'returns translation unit as lexical parent' do
-			parent.lexical_parent.kind.should eq(:cursor_translation_unit)
+			expect(parent.lexical_parent.kind).to eq(:cursor_translation_unit)
 		end
 	end
 
@@ -439,7 +431,7 @@ describe Cursor do
 		let (:struct) { find_all(cursor_canon, :cursor_struct).at(2) }
 
 		it "checks cursor is a definition" do
-			struct.definition?.should be true
+			expect(struct.definition?).to be true
 		end
 	end
 
@@ -447,16 +439,16 @@ describe Cursor do
 		let (:func) { find_first(cursor, :cursor_function) }
 
 		it "returns something in string" do
-			func.usr.should be_kind_of(String)
+			expect(func.usr).to be_kind_of(String)
 		end
 	end
 
-	describe '#variadic?', from_3_3: true do
+	describe '#variadic?' do
 		let(:func) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_function and child.spelling == 'f_variadic' } }
 
 		it "checks cursor is a variadic function" do
-			func.variadic?.should be true
+			expect(func.variadic?).to be true
 		end
 	end
 
@@ -467,7 +459,7 @@ describe Cursor do
 				child.kind == :cursor_type_ref and child.spelling == 'struct A' } }
 
 		it "returns a cursor that this cursor references" do
-			ref.referenced.should eq(struct)
+			expect(ref.referenced).to eq(struct)
 		end
 
 	end
@@ -476,7 +468,7 @@ describe Cursor do
 		let (:func) { find_first(cursor, :cursor_function) }
 
 		it "computes hash for the cursor" do
-			func.hash.should be_kind_of(Fixnum)
+			expect(func.hash).to be_kind_of(Fixnum)
 		end
 	end
 
@@ -484,7 +476,7 @@ describe Cursor do
 		let (:func) { find_first(cursor, :cursor_function) }
 
 		it "returns :available for the cursor availability" do
-			func.availability.should equal(:available)
+			expect(func.availability).to equal(:available)
 		end
 	end
 
@@ -492,8 +484,8 @@ describe Cursor do
 		let (:field) { find_first(cursor, :cursor_field_decl) }
 
 		it "returns type for the cursor" do
-			field.type.should be_kind_of(Type)
-			field.type.kind.should equal(:type_int)
+			expect(field.type).to be_kind_of(Type)
+			expect(field.type.kind).to equal(:type_int)
 		end
 	end
 
@@ -501,12 +493,12 @@ describe Cursor do
 		let (:typedef) { find_first(cursor_cxx, :cursor_typedef_decl) }
 
 		it "returns type that the cursor type is underlying" do
-			typedef.underlying_type.should be_kind_of(Type)
-			typedef.underlying_type.kind.should equal(:type_pointer)
+			expect(typedef.underlying_type).to be_kind_of(Type)
+			expect(typedef.underlying_type.kind).to equal(:type_pointer)
 		end
 	end
 
-	describe '#bitfield?', from_3_3: true do
+	describe '#bitfield?' do
 		let(:bitfield) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_field_decl and child.spelling == 'bit_field_a' } }
 		let(:non_bitfield) { find_matching(cursor_cxx) { |child, parent|
@@ -521,7 +513,7 @@ describe Cursor do
 		end
 	end
 
-	describe '#bitwidth', from_3_3: true do
+	describe '#bitwidth' do
 		let(:bitfield) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_field_decl and child.spelling == 'bit_field_a' } }
 		let(:non_bitfield) { find_matching(cursor_cxx) { |child, parent|