corefoundation 0.1.4 → 0.3.13

data/spec/dictionary_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-
-
-describe CF::Dictionary do
-  describe 'mutable' do
-    it 'should return  a cf dictionary' do
-      CF::Dictionary.mutable.should be_a(CF::Dictionary)
-    end
-  end
-
-  describe 'hash access' do
-    subject {CF::Dictionary.mutable}
-
-    it 'should return nil when the key does not exist' do
-      subject['doesnotexist'].should be_nil
-    end
-
-    it 'should raise when trying to store a non cf value' do
-      expect {subject[CF::String.from_string('key')]=1}.to raise_error(TypeError)
-    end
-
-    it 'should raise when trying to store a non cf key' do
-      expect {subject[1]=CF::String.from_string('value')}.to raise_error(TypeError)
-    end
-
-    it 'should allow storing and retrieving a cf key pair' do
-      subject[CF::String.from_string('key')] = CF::String.from_string('value')
-    end
-
-    it 'should instantiate the correct type on retrieval' do
-      subject[CF::String.from_string('key')] = CF::String.from_string('value')
-      subject[CF::String.from_string('key')].should be_a(CF::String)
-    end
-
-    it 'should coerce string keys' do
-      subject['key'] = CF::String.from_string('value')
-      subject['key'].to_s.should == 'value'
-    end
-  end
-
-  describe 'merge!' do
-    subject { CF::Dictionary.mutable.tap {|dict| dict['1'] = CF::Boolean::TRUE; dict['2'] = CF::Boolean::FALSE}}
-    it 'should merge the argument into the receiver' do
-      argument = {'1' => false, 'foo' => 'bar'}.to_cf
-      subject.merge! argument
-      subject.to_ruby.should == {'1' => false, '2' => false, 'foo' => 'bar'}
-    end
-  end
-
-  describe 'length' do
-    it 'should return the count of items in the dictionary' do
-      dict = CF::Dictionary.mutable
-      dict['one'] = CF::Boolean::TRUE
-      dict['two'] = CF::Boolean::TRUE
-
-      dict.length.should == 2
-    end
-  end
-
-  describe 'enumeration' do
-    subject { CF::Dictionary.mutable.tap {|dict| dict['1'] = CF::Boolean::TRUE; dict['2'] = CF::Boolean::FALSE}}
-
-    it 'should yield each key value pair in the dictionary' do
-      hash = {}
-      subject.each do |k,v|
-        hash[k] = v
-      end
-      hash.should == {CF::String.from_string('1') => CF::Boolean::TRUE, 
-                      CF::String.from_string('2') => CF::Boolean::FALSE}
-    end
-  end
-
-  describe 'to_ruby' do
-    subject { CF::Dictionary.mutable.tap {|dict| dict['1'] = CF::Boolean::TRUE; dict['2'] = CF::Array.immutable([CF::Boolean::FALSE])}}
-
-    it 'should return a ruby hash where keys and values have been converted to ruby types' do
-      subject.to_ruby.should == {'1' => true, '2' => [false]}
-    end
-  end
-
-end

data/spec/extensions_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe 'extensions' do
-  context 'with an integer' do
-    it 'should return a cfnumber' do
-      1.to_cf.should be_a(CF::Number)
-    end
-  end
-
-  context 'with a float' do
-    it 'should return a cfnumber' do
-      (1.0).to_cf.should be_a(CF::Number)
-    end
-  end
-
-  context 'with a 8bit string' do
-    it 'should return a cf data' do
-      '123'.encode(Encoding::ASCII_8BIT).to_cf.should be_a(CF::Data)
-    end
-  end
-
-  context 'with an asciistring' do
-    it 'should return a cf string' do
-      '123'.to_cf.should be_a(CF::String)
-    end
-  end
-
-  context 'with true' do
-    it 'should return CF::Boolean::TRUE' do
-      true.to_cf.should == CF::Boolean::TRUE
-    end
-  end
-
-  context 'with false' do
-    it 'should return CF::Boolean::FALSE' do
-      false.to_cf.should == CF::Boolean::FALSE
-    end
-  end
-
-  context 'with a time' do
-    it 'should return a CFDate' do
-      Time.now.to_cf.should be_a(CF::Date)
-    end
-  end
-
-  context 'with an array' do
-    it 'should return a cfarray containing cf objects' do
-      cf_array = [true, 1, 'hello'].to_cf
-      cf_array.should be_a(CF::Array)
-      cf_array[0].should == CF::Boolean::TRUE
-      cf_array[1].should be_a(CF::Number)
-      cf_array[2].should == CF::String.from_string('hello')
-    end
-  end
-
-  context 'with a dictionary' do
-    it 'should return a cfdictionary containing cf objects' do
-      cf_hash = {'key_1' => true, 'key_2' => false}.to_cf
-      cf_hash['key_1'].should == CF::Boolean::TRUE
-      cf_hash['key_2'].should == CF::Boolean::FALSE
-    end
-  end
-end

data/spec/null_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe CF::Null do
-  it 'should be null' do
-    CF::NULL.should be_null
-  end
-end

data/spec/number_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe CF::Number do
-
-  describe 'to_ruby' do
-    context 'with a number created from a float' do
-      subject {CF::Number.from_f('3.1415')} 
-      it 'should return a float' do
-        subject.to_ruby.should be_within(0.0000001).of(3.14150)
-      end
-    end
-    context 'with a number created from a int' do
-      subject {CF::Number.from_i('31415')} 
-      it 'should return a int' do
-        subject.to_ruby.should == 31415
-        subject.to_ruby.should be_a(Integer)
-      end
-    end
-  end
-
-  it 'should be comparable' do
-    (CF::Number.from_f('3.1415') <= CF::Number.from_i(4)).should be_true
-  end
-
-  describe('from_f') do 
-    it 'should create a cf number from a float' do
-      CF::Number.from_f('3.1415').should be_a(CF::Number)
-    end
-  end
-
-  describe('from_i') do 
-    it 'should create a cf number from a 32 bit sized int' do
-      CF::Number.from_i(2**30).should be_a(CF::Number)
-    end
-
-    it 'should create a cf number from a 64 bit sized int' do
-      CF::Number.from_i(2**60).should be_a(CF::Number)
-    end
-  end
-
-  describe('to_i') do
-    it 'should return a ruby integer representing the cfnumber' do
-      CF::Number.from_i(2**60).to_i.should == 2**60
-    end
-  end
-
-  describe('to_f') do
-    it 'should return a ruby float representing the cfnumber' do
-      CF::Number.from_f(3.1415).to_f.should be_within(0.0000001).of(3.14150)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,10 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-
-$: << File.dirname(__FILE__) + '/../lib'
-
-require 'corefoundation'
-
-RSpec.configure do |config|
-  
-end

data/spec/string_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe CF::String do
-
-  describe 'from_string' do
-    it 'should return a CF::String' do
-      CF::String.from_string('A CF string').should be_a(CF::String)
-    end
-
-    # The intent is to force feed CF::String with an invalid utf-8 string
-    # but jruby doesn't seem to allow this to be constructed
-    unless RUBY_ENGINE == 'jruby'
-      context 'with invalid data' do
-        it 'returns nil' do
-          CF::String.from_string("\xff\xff\xff".force_encoding('UTF-8')).should be_nil
-        end
-      end
-    end
-  end
-
-  describe '#to_s' do
-    it 'should return a utf ruby string' do
-      ruby_string = CF::String.from_string('A CF string').to_s
-      ruby_string.should == 'A CF string'
-      ruby_string.encoding.should == Encoding::UTF_8
-    end
-  end
-
-  describe 'to_ruby' do
-    it 'should behave like to_s' do
-      CF::String.from_string('A CF string').to_ruby.should == 'A CF string'
-      CF::String.from_string('A CF string').to_ruby.encoding.should == Encoding::UTF_8
-    end
-  end
-
-  it 'should be comparable' do
-    CF::String.from_string('aaa').should  <= CF::String.from_string('zzz')
-  end
-end