ffi-clang 0.7.0 → 0.8.0

data/spec/ffi/clang/token_spec.rb

@@ -1,82 +0,0 @@
-# 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.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-describe Tokens do
-	let(:translation_unit) { Index.new.parse_translation_unit(fixture_path("list.c")) }
-	let(:cursor) { translation_unit.cursor }
-	let(:range) { find_first(cursor, :cursor_struct).extent }
-	let(:tokens) { translation_unit.tokenize(range) }
-
-	it "can be obtained from a translation unit" do
-		expect(tokens).to be_kind_of(Tokens)
-		expect(tokens.size).to be >= 12
-		expect(tokens.tokens).to be_kind_of(Array)
-		expect(tokens.tokens.first).to be_kind_of(Token)
-	end
-
-	it "calls dispose_tokens on GC" do
-		tokens.autorelease = false
-		expect(Lib).to receive(:dispose_tokens).at_least(:once)
-		expect{tokens.free}.not_to raise_error
-	end
-
-	it "#each" do
-		spy = double(stub: nil)
-		expect(spy).to receive(:stub).exactly(tokens.size).times
-		tokens.each { spy.stub }
-	end
-
-	it "#cursors" do
-		expect(tokens.cursors).to be_kind_of(Array)
-		expect(tokens.cursors.size).to eq(tokens.size)
-		expect(tokens.cursors.first).to be_kind_of(Cursor)
-	end
-end
-
-describe Token do
-	let(:translation_unit) { Index.new.parse_translation_unit(fixture_path("list.c")) }
-	let(:cursor) { translation_unit.cursor }
-	let(:range) { find_first(cursor, :cursor_struct).extent }
-	let(:token) { translation_unit.tokenize(range).first }
-
-	it "can be obtained from a translation unit" do
-		expect(token).to be_kind_of(Token)
-	end
-
-	it "#kind" do
-		expect(token.kind).to be_kind_of(Symbol)
-		expect(token.kind).to eq(:keyword)
-	end
-
-	it "#spelling" do
-		expect(token.spelling).to be_kind_of(String)
-		expect(token.spelling).to eq('struct')
-	end
-
-	it "#location" do
-		expect(token.location).to be_kind_of(SourceLocation)
-		expect(token.location.line).to eq(1)
-	end
-
-	it "#extent" do
-		expect(token.extent).to be_kind_of(SourceRange)
-		expect(token.extent.start.line).to eq(1)
-	end
-end

data/spec/ffi/clang/translation_unit_spec.rb

@@ -1,220 +0,0 @@
-# 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.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-describe TranslationUnit do
-	before :all do
-		FileUtils.mkdir_p TMP_DIR
-	end
-
-	after :all do
-		FileUtils.rm_rf TMP_DIR
-	end
-
-	let(:translation_unit) { Index.new.parse_translation_unit fixture_path("a.c") }
-
-	it "returns a list of diagnostics" do
-		diags = translation_unit.diagnostics
-		expect(diags).to be_kind_of(Array)
-		expect(diags).to_not be_empty
-	end
-
-	it "returns a list of diagnostics from an unsaved file" do
-		file = UnsavedFile.new("a.c", File.read(fixture_path("a.c")))
-		translation_unit = Index.new.parse_translation_unit("a.c", nil,[file])
-		diags = translation_unit.diagnostics
-		expect(diags).to be_kind_of(Array)
-		expect(diags).to_not be_empty
-	end
-
-	it "calls dispose_translation_unit on GC" do
-		translation_unit.autorelease = false
-		# expect(Lib).to receive(:dispose_translation_unit).with(translation_unit).once
-		expect{translation_unit.free}.not_to raise_error
-	end
-
-	describe "#spelling" do
-		let (:spelling) { translation_unit.spelling }
-
-		it "returns own filename" do
-			expect(spelling).to be_kind_of(String)
-			expect(spelling).to eq(fixture_path("a.c"))
-		end
-	end
-
-	describe "#file" do
-		let (:specified_file) { translation_unit.file(fixture_path("a.c")) }
-		let (:unspecified_file) { translation_unit.file }
-
-		it "returns File instance" do
-			expect(specified_file).to be_kind_of(FFI::Clang::File)
-		end
-
-		it "returns main file when file name is not specified" do
-			expect(unspecified_file).to be_kind_of(FFI::Clang::File)
-			expect(unspecified_file.name).to include("a.c")
-		end
-	end
-
-	describe "#location" do
-		let(:file) { translation_unit.file(fixture_path("a.c")) }
-		let(:column) { 12 }
-		let(:location) { translation_unit.location(file, 1, column) }
-
-		it "returns source location at a specific point" do
-			expect(location).to be_kind_of(SourceLocation)
-			expect(location.file).to eq(fixture_path("a.c"))
-			expect(location.line).to eq(1)
-			expect(location.column).to eq(column)
-		end
-	end
-
-	describe "#location_offset" do
-		let(:file) { translation_unit.file(fixture_path("a.c")) }
-		let(:offset) { 10 }
-		let(:location) { translation_unit.location_offset(file, offset) }
-
-		it "returns source location at a specific offset point" do
-			expect(location).to be_kind_of(SourceLocation)
-			expect(location.file).to eq(fixture_path("a.c"))
-			expect(location.column).to eq(offset+1)
-		end
-	end
-
-	describe "#cursor" do
-		let(:cursor) { translation_unit.cursor }
-		let(:location) { translation_unit.location(translation_unit.file(fixture_path("a.c")), 1, 10) }
-		let(:cursor_with_loc) { translation_unit.cursor(location) }
-
-		it "returns translation unit cursor if no arguments are specified" do
-			expect(cursor).to be_kind_of(Cursor)
-			expect(cursor.kind).to eq(:cursor_translation_unit)
-		end
-
-		it "returns a correspond cursor if a source location is passed" do
-			expect(cursor_with_loc).to be_kind_of(Cursor)
-			expect(cursor_with_loc.kind).to eq(:cursor_parm_decl)
-		end
-	end
-
-	describe "#self.default_editing_translation_unit_options" do
-		let (:opts) { FFI::Clang::TranslationUnit.default_editing_translation_unit_options }
-		it "returns hash with symbols of TranslationUnitFlags" do
-			expect(opts).to be_kind_of(Hash)
-			opts.keys.each { |key|
-				expect(FFI::Clang::Lib::TranslationUnitFlags.symbols).to include(key)
-			}
-		end
-	end
-
-	describe "#default_save_options" do
-		let (:opts) { translation_unit.default_save_options }
-		it "returns hash with symbols of SaveTranslationUnitFlags" do
-			expect(opts).to be_kind_of(Hash)
-			opts.keys.each { |key|
-				expect(FFI::Clang::Lib::SaveTranslationUnitFlags.symbols).to include(key)
-			}
-		end
-	end
-
-	describe "#save" do
-		let (:filepath) { "#{TMP_DIR}/save_translation_unit" }
-		let (:may_not_exist_filepath) { "#{TMP_DIR}/not_writable_directory/save_translation_unit" }
-		it "saves translation unit as a file" do
-			expect{translation_unit.save(filepath)}.not_to raise_error
-			expect(FileTest.exist?(filepath)).to be true
-		end
-
-		it "raises exception if save path is not writable" do
-			FileUtils.mkdir_p File.dirname(may_not_exist_filepath)
-			File.chmod(0444, File.dirname(may_not_exist_filepath))
-			expect{translation_unit.save(may_not_exist_filepath)}.to raise_error(FFI::Clang::Error)
-			expect(FileTest.exist?(may_not_exist_filepath)).to be false
-		end
-	end
-
-	describe "#default_reparse_options" do
-		let (:opts) { translation_unit.default_reparse_options }
-		it "returns hash with symbols of ReparseFlags" do
-			expect(opts).to be_kind_of(Hash)
-			opts.keys.each { |key|
-				expect(FFI::Clang::Lib::ReparseFlags.symbols).to include(key)
-			}
-		end
-	end
-
-	describe "#reparse" do
-		let (:path) { "#{TMP_DIR}/reparse_tmp.c" }
-		before :each do
-			FileUtils.touch path
-			@reparse_translation_unit = Index.new.parse_translation_unit(path)
-		end
-		after :each do
-			FileUtils.rm path, :force => true
-		end
-
-		it "recretes translation unit" do
-			File::open(path, "w+") { |io|
-			   io.write("int a;")
-			}
-			expect(find_first(@reparse_translation_unit.cursor, :cursor_variable)).to be nil
-			expect{@reparse_translation_unit.reparse}.not_to raise_error
-			expect(find_first(@reparse_translation_unit.cursor, :cursor_variable).spelling).to eq("a")
-		end
-
-		it "raises exception if the file is not found when reparsing" do
-			FileUtils.rm path, :force => true
-			expect{@reparse_translation_unit.reparse}.to raise_error(FFI::Clang::Error)
-		end
-	end
-
-	describe "#resource_usage" do
-		let (:ru) { translation_unit.resource_usage }
-		it "returns ResourceUsage instance that represents memory usage of TU" do
-			expect(ru).to be_kind_of(TranslationUnit::ResourceUsage)
-		end
-	end
-
-	describe TranslationUnit::ResourceUsage do
-		let (:ru) { translation_unit.resource_usage }
-		describe "#entries" do
-			let (:entries) { translation_unit.resource_usage.entries }
-			it "returns array of CXTUResourceUsageEntry" do
-				expect(entries).to be_kind_of(Array)
-				expect(entries.first).to be_kind_of(Lib::CXTUResourceUsageEntry)
-				expect(entries.first[:kind]).to be_kind_of(Symbol)
-				expect(entries.first[:amount]).to be_kind_of(Integer)
-			end
-		end
-
-		describe "#self.name" do
-			let(:name) { FFI::Clang::TranslationUnit::ResourceUsage.name(:ast) }
-			it "returns the name of the memory category" do
-				expect(name).to be_kind_of(String)
-			end
-		end
-
-		describe "#self.release" do
-			it "releases data by calling 'clang_disposeCXTUResourceUsage'" do
-				ru.autorelease = false
-				expect{ ru.free }.not_to raise_error
-			end
-		end
-	end
-end

data/spec/ffi/clang/type_spec.rb

@@ -1,273 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright, 2013, by Carlos Martín Nieto <cmn@dwim.me>
-# 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.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-describe Type do
-	let(:cursor) { Index.new.parse_translation_unit(fixture_path("a.c")).cursor }
-	let(:cursor_cxx) { Index.new.parse_translation_unit(fixture_path("test.cxx")).cursor }
-	let(:cursor_list) { Index.new.parse_translation_unit(fixture_path("list.c")).cursor }
-	let(:type) { find_first(cursor, :cursor_function).type }
-
-	it "can tell us about the main function" do
-		expect(type.variadic?).to equal(false)
-
-		expect(type.num_arg_types).to equal(2)
-		expect(type.arg_type(0).spelling).to eq("int")
-		expect(type.arg_type(1).spelling).to eq("const char *")
-		expect(type.result_type.spelling).to eq("int")
-	end
-
-  describe '#kind_spelling' do
-    let(:kind_spelling_type) { find_matching(cursor_cxx) { |child, parent|
-      child.kind == :cursor_typedef_decl and child.spelling == 'const_int_ptr'}.type }
-
-    it 'returns type kind name with string' do
-      expect(kind_spelling_type.kind_spelling).to eq 'Typedef'
-    end
-  end
-
-  describe '#canonical' do
-    let(:canonical_type) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_typedef_decl and child.spelling == 'const_int_ptr'
-      }.type.canonical }
-
-    it 'extracts typedef' do
-      expect(canonical_type).to be_kind_of(Type)
-      expect(canonical_type.kind).to be(:type_pointer)
-      expect(canonical_type.spelling).to eq('const int *')
-    end
-  end
-
-  describe '#pointee' do
-    let(:pointee_type) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_typedef_decl and child.spelling == 'const_int_ptr'
-      }.type.canonical.pointee }
-
-    it 'gets pointee type of pointer, C++ reference' do
-      expect(pointee_type).to be_kind_of(Type)
-      expect(pointee_type.kind).to be(:type_int)
-      expect(pointee_type.spelling).to eq('const int')
-    end
-  end
-
-  describe '#const_qualified?' do
-    let(:pointer_type) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_typedef_decl and child.spelling == 'const_int_ptr'
-      }.type.canonical }
-
-    let(:pointee_type) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_typedef_decl and child.spelling == 'const_int_ptr'
-      }.type.canonical.pointee }
-
-    it 'checks type is const qualified' do
-      expect(pointee_type.const_qualified?).to equal true
-    end
-
-    it 'cannot check whether pointee type is const qualified' do
-      expect(pointer_type.const_qualified?).to equal false
-    end
-  end
-
-  describe '#volatile_qualified?' do
-    let(:pointer_type) { find_matching(cursor) { |child, parent|
-        child.kind == :cursor_variable and child.spelling == 'volatile_int_ptr'
-      }.type }
-
-    it 'checks type is volatile qualified' do
-      expect(pointer_type.volatile_qualified?).to be true
-    end
-  end
-
-  describe '#restrict_qualified?' do
-    let(:pointer_type) { find_matching(cursor) { |child, parent|
-        child.kind == :cursor_variable and child.spelling == 'restrict_int_ptr'
-      }.type }
-
-    it 'checks type is restrict qualified' do
-      expect(pointer_type.restrict_qualified?).to be true
-    end
-  end
-
-  describe '#element_type' do
-    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_variable and child.spelling == 'int_array'
-      }.type }
-
-    it 'returns the element type of the array type' do
-      expect(array_type.element_type).to be_kind_of(Type)
-      expect(array_type.element_type.kind).to eq(:type_int)
-    end
-  end
-
-  describe '#num_elements' do
-    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_variable and child.spelling == 'int_array'
-      }.type }
-
-    it 'returns the number of elements of the array' do
-      expect(array_type.num_elements).to eq(8)
-    end
-  end
-
-  describe '#array_element_type' do
-    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_variable and child.spelling == 'int_array'
-      }.type }
-
-    it 'returns the array element type of the array type' do
-      expect(array_type.array_element_type).to be_kind_of(Type)
-      expect(array_type.array_element_type.kind).to eq(:type_int)
-    end
-  end
-
-  describe '#array_size' do
-    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_variable and child.spelling == 'int_array'
-      }.type }
-
-    it 'returns the number of elements of the array' do
-      expect(array_type.array_size).to eq(8)
-    end
-  end
-
-  describe '#alignof' do
-    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_variable and child.spelling == 'int_array'
-      }.type }
-
-    it 'returns the alignment of the type in bytes' do
-      expect(array_type.alignof).to be_kind_of(Integer)
-      expect(array_type.alignof).to be > 0
-    end
-  end
-
-  describe '#sizeof' do
-    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_variable and child.spelling == 'int_array'
-      }.type }
-
-    it 'returns the size of the type in bytes' do
-      expect(array_type.sizeof).to be_kind_of(Integer)
-      expect(array_type.sizeof).to be(32)
-    end
-  end
-
-  describe '#offsetof' do
-    let(:struct) { find_matching(cursor_list) { |child, parent|
-        child.kind == :cursor_struct and child.spelling == 'List'
-      }.type }
-
-    it 'returns the offset of a field in a record of the type in bits' do
-      expect(struct.offsetof('Next')).to be_kind_of(Integer)
-      expect(struct.offsetof('Next')).to be(64)
-    end
-  end
-
-  describe '#ref_qualifier' do
-    let(:lvalue) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_cxx_method and child.spelling == 'func_lvalue_ref'
-      }.type }
-    let(:rvalue) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_cxx_method and child.spelling == 'func_rvalue_ref'
-      }.type }
-    let(:none) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_cxx_method and child.spelling == 'func_none'
-      }.type }
-
-    it 'returns :ref_qualifier_lvalue the type is ref-qualified with lvalue' do
-      expect(lvalue.ref_qualifier).to be(:ref_qualifier_lvalue)
-    end
-
-    it 'returns :ref_qualifier_rvalue the type is ref-qualified with rvalue' do
-      expect(rvalue.ref_qualifier).to be(:ref_qualifier_rvalue)
-    end
-
-    it 'returns :ref_qualifier_none the type is not ref-qualified' do
-      expect(none.ref_qualifier).to be(:ref_qualifier_none)
-    end
-  end
-
-  describe '#pod?' do
-    let(:struct) { find_matching(cursor_list) { |child, parent|
-        child.kind == :cursor_struct and child.spelling == 'List'
-      }.type }
-
-    it 'returns true if the type is a POD type' do
-      expect(struct.pod?).to be true
-    end
-  end
-
-  describe '#class_type' do
-    let(:member_pointer) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_variable and child.spelling == 'member_pointer'
-      }.type }
-
-    it 'returns the class type of the member pointer type' do
-      expect(member_pointer.class_type).to be_kind_of(Type)
-      expect(member_pointer.class_type.kind).to be(:type_record)
-      expect(member_pointer.class_type.spelling).to eq('A')
-    end
-  end
-
-  describe '#declaration' do
-    let(:struct_ref) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_type_ref and child.spelling == 'struct D'
-      }.type }
-    let(:struct_decl) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_struct and child.spelling == 'D'
-      } }
-    let(:no_decl) { find_first(cursor_cxx, :cursor_cxx_method).type }
-
-    it 'returns the class type of the member pointer type' do
-      expect(struct_ref.declaration).to be_kind_of(Cursor)
-      expect(struct_ref.declaration.kind).to be(:cursor_struct)
-      expect(struct_ref.declaration).to eq(struct_decl)
-    end
-
-    it 'returns :cursor_no_decl_found if the type has no declaration' do
-      expect(no_decl.declaration).to be_kind_of(Cursor)
-      expect(no_decl.declaration.kind).to be(:cursor_no_decl_found)
-    end
-  end
-
-  describe '#calling_conv' do
-    let(:function) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_function and child.spelling == 'f_variadic'
-      }.type }
-
-    it 'returns the calling convention associated with the function type' do
-      expect(function.calling_conv).to be(:calling_conv_c)
-    end
-  end
-
-  describe '#==' do
-    let(:type_decl) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_field_decl and child.spelling == 'int_member_a'
-      }.type }
-    let(:type_ref) { find_matching(cursor_cxx) { |child, parent|
-        child.kind == :cursor_decl_ref_expr and child.spelling == 'int_member_a'
-      }.type }
-
-    it 'checks if two types represent the same type' do
-      expect(type_decl == type_ref).to be true
-    end
-  end
-end

data/spec/ffi/clang/version_spec.rb

@@ -1,28 +0,0 @@
-# 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.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-require 'ffi/clang/version'
-
-describe FFI::Clang.clang_version_string do
-	it "returns a version string for showing to user" do
-		expect(subject).to be_kind_of(String)
-		expect(subject).to match(/Apple LLVM version \d+\.\d+\.\d+|clang version \d+\.\d+/)
-	end
-end

data/spec/spec_helper.rb

@@ -1,51 +0,0 @@
-
-require_relative '../lib/ffi/clang'
-
-require 'pry'
-
-include FFI::Clang
-
-TMP_DIR = File.expand_path("tmp", __dir__)
-
-module ClangSpecHelper
-	def fixture_path(path)
-		File.join File.expand_path("ffi/clang/fixtures", __dir__), path
-	end
-
-	def find_all(cursor, kind)
-		cursor.find_all(kind)
-	end
-
-	def find_first(cursor, kind)
-		cursor.find_first(kind)
-	end
-
-	def find_all_matching(cursor, &term)
-		cursor.filter(&term)
-	end
-
-	def find_matching(cursor, &term)
-		cursor.filter(&term).first
-	end
-end
-
-RSpec.configure do |config|
-	# Enable flags like --only-failures and --next-failure
-	config.example_status_persistence_file_path = ".rspec_status"
-	
-	config.include ClangSpecHelper
-	
-	supported_versions = ['3.4', '3.5', '3.6', '3.7', '3.8', '3.9', '4.0']
-	current_version = ENV['LLVM_VERSION'] || supported_versions.last
-	supported_versions.reverse_each { |version|
-		break if version == current_version
-		sym = ('from_' + version.tr('.', '_')).to_sym
-		config.filter_run_excluding sym => true
-	}
-
-	supported_versions.each { |version|
-		break if version == current_version
-		sym = ('upto_' + version.tr('.', '_')).to_sym
-		config.filter_run_excluding sym => true
-	}
-end