ffi-clang

compilation_database_spec.rb (5999B)

---

 # 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 CompilationDatabase do
 	let(:dirpath) { fixture_path('') }
 	let(:cdb) { CompilationDatabase.new(dirpath) }
 	let(:file) { '/home/xxxxx/src/llvm-trunk/lib/Support/APFloat.cpp' }
 
 	it "can be created" do
 		expect(cdb).to be_kind_of(CompilationDatabase)
 	end
 
 	it "raises DatabaseLoadError if cannot be created" do
 		expect{CompilationDatabase.new('/not/exist/directory')}.to raise_error FFI::Clang::CompilationDatabase::DatabaseLoadError
 	end
 
 	it "calls compilation_database_dispose on GC" do
 		cdb.autorelease = false
 		# expect(Lib).to receive(:compilation_database_dispose).with(cdb).once
 		expect{cdb.free}.not_to raise_error
 	end
 
 	describe '#compile_commands' do
 		let(:not_found_file) { '/home/xxxxx/not_found_file_path' }
 
 		it "returns compile commands used for a file" do
 			expect(cdb.compile_commands(file)).to be_kind_of(CompilationDatabase::CompileCommands)
 			expect(cdb.compile_commands(file).size).to eq(1)
 		end
 
 		it "returns compile commands if the specified file is not found" do
 			expect(cdb.compile_commands(not_found_file)).to be_kind_of(CompilationDatabase::CompileCommands)
 			if FFI::Clang.clang_version_string[/\d+/].to_i >= 10
 				expect(cdb.compile_commands(not_found_file).size).to eq(1)
 			else
 				expect(cdb.compile_commands(not_found_file).size).to eq(0)
 			end
 		end
 	end
 
 	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)
 		end
 	end
 
 	describe CompilationDatabase::CompileCommands do
 		let(:commands) { cdb.compile_commands(file) }
 
 		it "calls compile_commands_dispose on GC" do
 			commands.autorelease = false
 			# expect(Lib).to receive(:compile_commands_dispose).with(commands).once
 			expect{commands.free}.not_to raise_error
 		end
 
 		describe '#size' do
 			it "returns the number of CompileCommand" do
 				expect(commands.size).to be_kind_of(Integer)
 				expect(commands.size).to eq(1)
 			end
 
 			it "returns the number of CompileCommand" do
 				expect(cdb.all_compile_commands.size).to eq(3)
 			end
 		end
 
 		describe '#command' do
 			it "returns the I'th CompileCommand" do
 				expect(commands.command(0)).to be_kind_of(CompilationDatabase::CompileCommand)
 			end
 		end
 
 		describe "#commands" do
 			it "returns all CompileCommand as Array" do
 				expect(commands.commands).to be_kind_of(Array)
 				expect(commands.commands.first).to be_kind_of(CompilationDatabase::CompileCommand)
 				expect(commands.commands.size).to eq(commands.size)
 			end
 		end
 
 		describe "#each" do
 			let(:spy) { double(stub: nil) }
 			it "calls block once for each CompileCommand" do
 				expect(spy).to receive(:stub).exactly(commands.size).times
 				commands.each { spy.stub }
 			end
 		end
 	end
 
 	describe CompilationDatabase::CompileCommand do
 		let(:cmd) { cdb.compile_commands(file).first }
 
 		describe '#directory' do
 			it "returns the working directory" do
 				expect(cmd.directory).to be_kind_of(String)
 				expect(cmd.directory).to eq('/home/xxxxx/src/build-trunk/lib/Support')
 			end
 		end
 
 		describe '#num_args' do
 			it "returns the number of CompileCommand" do
 				expect(cmd.num_args).to be_kind_of(Integer)
 				expect(cmd.num_args).to be >= 31 # clang may insert additional args
 			end
 		end
 
 		describe '#arg' do
 			it "returns the I'th argument value" do
 				expect(cmd.arg(0)).to be_kind_of(String)
 				expect(cmd.arg(0)).to eq('/opt/llvm/3.4/bin/clang++')
 			end
 		end
 
 		describe '#args' do
 			it "returns all argument values as Array" do
 				expect(cmd.args).to be_kind_of(Array)
 				expect(cmd.args.first).to be_kind_of(String)
 				expect(cmd.args.size).to eq(cmd.num_args)
 			end
 		end
 
 		describe '#num_mapped_sources' do
 			# TODO: a case which has mapped sources
 
 			it "returns the number of source mappings" do
 				# expect(cmd.num_mapped_sources).to be_kind_of(Integer)
 				# expect(cmd.num_mapped_sources).to eq(0)
 			end
 		end
 
 		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)
 			end
 
 			it "returns nil if the index exceeds element size" do
 				# expect(cmd.mapped_source_path(1000)).to be_nil
 			end
 		end
 
 		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)
 			end
 
 			it "returns nil if the index exceeds element size" do
 				# expect(cmd.mapped_source_content(1000)).to be_nil
 			end
 		end
 
 		describe '#mapped_sources' do
 			# TODO: a case which has mapped sources
 
 			it "returns all mapped sources as Array" do
 				# expect(cmd.mapped_sources).to be_kind_of(Array)
 				# expect(cmd.mapped_sources.size).to eq(cmd.num_mapped_sources)
 			end
 		end
 	end
 end