ffi-clang

translation_unit_spec.rb (7547B)

---

 # 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