ffi-clang

type_spec.rb (10009B)

---

 # -*- 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