ruby_android 0.0.2 → 0.7.2

data/spec/dex/info_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+shared_context 'with sample_classes.dex', with: :sample_dex do
+  let(:dex_path){ File.expand_path(File.dirname(__FILE__) + '/../data/sample_classes.dex') }
+  let(:dex_bin){ File.open(dex_path, 'rb') {|f| f.read } }
+  let(:dex){ Android::Dex.new(dex_bin) }
+  let(:last_class) { dex.classes.last }
+end
+describe Android::Dex::ClassInfo do
+  include_context 'with sample_classes.dex'
+  context 'about the last class in Dex#classes with sample_classes.dex' do
+    let(:last_class) { dex.classes.last }
+    its(:name){ should eq 'Lexample/app/sample/SampleCode;' }
+    its(:access_flags){ should be_instance_of Android::Dex::ClassAccessFlag }
+    its(:super_class){ should eq 'Ljava/lang/Object;' }
+    its(:class_data){ should be_instance_of Android::Dex::DexObject::ClassDataItem }
+    its(:class_def){ should be_instance_of Android::Dex::DexObject::ClassDefItem }
+    its(:definition) { should eq 'public class Lexample/app/sample/SampleCode; extends Ljava/lang/Object;' }
+
+    subject { last_class }
+    describe '#static_fields' do
+      subject { last_class.static_fields }
+      it { should have(1).item }
+      specify { subject[0].should be_instance_of Android::Dex::FieldInfo }
+    end
+    describe '#instance_fields' do
+      subject { last_class.instance_fields }
+      it { should have(1).item }
+      specify { subject[0].should be_instance_of Android::Dex::FieldInfo }
+    end
+    describe '#direct_methods' do
+      subject { last_class.direct_methods }
+      it { should have(3).items }
+      specify { subject[0].should be_instance_of Android::Dex::MethodInfo }
+    end
+    describe '#virtual_methods' do
+      subject { last_class.virtual_methods }
+      it { should have(18).items }
+      specify { subject[0].should be_instance_of Android::Dex::MethodInfo }
+    end
+  end
+  context 'when class_data_item is nil' do
+    let(:mock_cls_def) {
+      s = double(Android::Dex::DexObject::ClassDefItem)
+      s.stub(:'[]').with(anything()).and_return(0)
+      s.stub(:class_data_item).and_return(nil)
+      s
+    }
+    let(:class_info) { Android::Dex::ClassInfo.new(mock_cls_def, nil) }
+    describe '#static_fields' do
+      subject { class_info.static_fields }
+      it { should be_kind_of Array }
+      it { should be_empty }
+    end
+    describe '#instance_fields' do
+      subject { class_info.instance_fields }
+      it { should be_kind_of Array }
+      it { should be_empty }
+    end
+    describe '#direct_methods' do
+      subject { class_info.direct_methods }
+      it { should be_kind_of Array }
+      it { should be_empty }
+    end
+    describe '#virtual_methods' do
+      subject { class_info.virtual_methods }
+      it { should be_kind_of Array }
+      it { should be_empty }
+    end
+  end
+end
+
+describe Android::Dex::FieldInfo do
+  include_context 'with sample_classes.dex'
+  context 'about the first static field of the last class with sample_classes.dex'do
+    let(:first_static_field) { last_class.static_fields.first }
+    subject { first_static_field }
+    its(:name) { should eq 'TAG' }
+    its(:type) { should eq 'Ljava/lang/String;' }
+    describe '#access_flags' do
+      subject { first_static_field.access_flags }
+      it { should be_instance_of Android::Dex::ClassAccessFlag }
+      specify { subject.to_s.should eq 'private static final' }
+    end
+    describe '#definition' do
+      subject { first_static_field.definition }
+      it { should eq 'private static final Ljava/lang/String; TAG' }
+    end
+  end
+end
+
+describe Android::Dex::MethodInfo do
+  include_context 'with sample_classes.dex'
+  context 'about the first direct method of the last class' do
+    let(:first_direct_method) { last_class.direct_methods.first }
+    subject { first_direct_method }
+    its(:name) { should eq '<init>' }
+  end
+  context 'about the first virtual method of the last class' do
+    let(:first_virtual_method) { last_class.virtual_methods.first }
+    subject { first_virtual_method }
+    its(:name) { should eq 'processDoWhile' }
+    its(:code_item) { should be_instance_of Android::Dex::DexObject::CodeItem }
+    describe '#parameters' do
+      subject { first_virtual_method.parameters }
+      it { should have(1).item }
+      it { should include('int') }
+    end
+  end
+  context 'about the 12th virtual method(processTryCatch) of the last class' do
+    let(:a_virtual_method) { last_class.virtual_methods[12]}
+    subject { a_virtual_method }
+    its(:name) { should eq 'processTryCatch' }
+    describe '#code_item' do
+      subject { a_virtual_method.code_item }
+      it { should be_instance_of Android::Dex::DexObject::CodeItem }
+      its(:debug_info_item) { should be_instance_of Android::Dex::DexObject::DebugInfoItem }
+    end
+  end
+end
+

data/spec/dex/utils_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Android::Dex do
+
+  describe ".uleb128" do
+    # @see http://en.wikipedia.org/wiki/LEB128
+    it "[0x00] should be 0" do
+      Android::Dex.uleb128("\x00").should == [0,1]
+    end
+    it "[0x01] should be 1" do
+      Android::Dex.uleb128("\x01").should == [1,1]
+    end
+    it "[0x7f] should be 127" do
+      Android::Dex.uleb128("\x7f").should == [127,1]
+    end
+    it "[0x80,0x7f] should be 16256" do
+      Android::Dex.uleb128("\x80\x7f").should == [16256,2]
+    end
+    it "[0xe5,0x8e,0x26] should be 624485" do
+      Android::Dex.uleb128("\xe5\x8e\x26").should == [624485,3]
+    end
+  end
+
+  describe ".uleb128p1" do
+    it "[0x00] should be -1" do
+      Android::Dex.uleb128p1("\x00").should == [-1,1]
+    end
+    it "[0x01] should be 0" do
+      Android::Dex.uleb128p1("\x01").should == [0,1]
+    end
+    it "[0x7f] should be 126" do
+      Android::Dex.uleb128p1("\x7f").should == [126,1]
+    end
+    it "[0x80,0x7f] should be 16255" do
+      Android::Dex.uleb128p1("\x80\x7f").should == [16255,2]
+    end
+    it "[0xe5,0x8e,0x26] should be 624485" do
+      Android::Dex.uleb128("\xe5\x8e\x26").should == [624485,3]
+    end
+  end
+  describe '.sleb128' do
+    it "[0x00] should be 0" do
+      Android::Dex.sleb128("\x00").should == [0,1]
+    end
+    it "[0x01] should be 1" do
+      Android::Dex.sleb128("\x01").should == [1,1]
+    end
+    it "[0x7f] should be -1" do
+      Android::Dex.sleb128("\x7f").should == [-1,1]
+    end
+    it "[0x80,0x7f] should be 127" do
+      Android::Dex.sleb128("\x80\x7f").should == [-128,2]
+    end
+  end
+end
+

data/spec/dex_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Android::Dex do
+  let(:dex_path){ File.expand_path(File.dirname(__FILE__) + '/data/sample_classes.dex') }
+  let(:dex_bin){ File.open(dex_path, 'rb') {|f| f.read } }
+  let(:dex){ Android::Dex.new(dex_bin) }
+
+
+  describe '#initialize' do
+    subject { dex }
+    context 'with valid dex data' do
+      it { should be_instance_of(Android::Dex) }
+    end
+    context 'with nil data' do
+      let(:dex_bin) { nil }
+      specify { expect{ subject }.to raise_error  }
+    end
+  end
+
+  describe '#data' do
+    subject { dex.data }
+    it { should be_instance_of String }
+    specify { subject.encoding.should eq Encoding::ASCII_8BIT }
+  end
+
+  describe '#strings' do
+    let(:num_str) { dex.header[:string_ids_size] }
+    subject { dex.strings }
+    it { should be_instance_of Array }
+    it 'should have string_ids_size items' do
+      should have(num_str).items
+    end
+    it "should be the particular string(depends on sample_classes.dex)" do
+      subject[0].should eq "%d"
+    end
+    it "should be the particular string(depends on sample_classes.dex)" do
+      subject[1].should eq "<init>"
+    end
+    it "should be the particular string(depends on sample_classes.dex)" do
+      subject[2].should eq "BuildConfig.java"
+    end
+  end
+    describe '#inspect' do
+      subject { dex.inspect }
+      it { should match(/\A<Android::Dex.*>\Z/m) }
+    end
+
+  describe '#classes' do
+    subject { dex.classes }
+    let(:num_classes) { dex.header[:class_defs_size] }
+    it{ should be_instance_of Array }
+    it{ should have(num_classes).items }
+    describe 'first item' do
+      subject { dex.classes.first }
+      it{ should be_instance_of Android::Dex::ClassInfo }
+    end
+  end
+end
+

data/spec/layout_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Android::Layout do
+  context 'with real apk sample file' do
+    let(:apk_path){ File.expand_path(File.dirname(__FILE__) + '/data/sample.apk') }
+    let(:apk){ Android::Apk.new(apk_path) }
+    let(:layouts) { apk.layouts }
+    subject { layouts }
+    it { should be_a Hash }
+    it { should have_key "res/layout/main.xml" }
+    it { should have(1).item }
+    context 'about first item' do
+      subject { layouts['res/layout/main.xml'] }
+      it { should be_a Android::Layout }
+      describe '#path' do
+        it { subject.path.should eq 'res/layout/main.xml' }
+      end
+      describe '#doc' do
+        it { subject.doc.should be_a REXML::Document }
+      end
+      describe '#to_xml' do
+        it { subject.to_xml.should be_a String }
+      end
+    end
+  end
+end
+

data/spec/manifest_spec.rb

@@ -0,0 +1,221 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Android::Manifest do
+  describe Android::Manifest::Component do
+    describe "self.valid?" do
+      let(:elem) { REXML::Element.new('service') }
+      subject { Android::Manifest::Component.valid?(elem) }
+      context "with valid component element" do
+        it { should be_true }
+      end
+      context "with invalid component element" do
+        let(:elem) { REXML::Element.new('invalid-name') }
+        it { should be_false }
+      end
+      context "when some exception occurs in REXML::Element object" do
+        let(:elem) {
+          elem = stub(REXML::Element)
+          elem.stub(:name).and_raise(StandardError)
+          elem
+        }
+        it { should be_false }
+      end
+    end
+    describe '#metas' do
+      subject { Android::Manifest::Component.new(elem).metas }
+      context 'with valid component element has 2 meta elements' do
+        let(:elem) { 
+          elem = REXML::Element.new('service') 
+          elem << REXML::Element.new('meta-data')
+          elem << REXML::Element.new('meta-data')
+          elem
+        }
+        it { should have(2).item }
+      end
+    end
+    describe '#elem' do
+      subject { Android::Manifest::Component.new(elem).elem }
+      let(:elem) { REXML::Element.new('service') }
+      it { should eq elem }
+    end
+
+    describe Android::Manifest::Meta do
+      let(:elem) do
+        attrs = { 'name' => 'meta name', 'resource' => 'res', 'value' => 'val' }
+        elem = stub(REXML::Element, :attributes => attrs)
+        elem
+      end
+      subject { Android::Manifest::Meta.new(elem) }
+      its(:name) { should eq 'meta name' }
+      its(:resource) { should eq 'res' }
+      its(:value) { should eq 'val' }
+    end
+  end
+
+  describe Android::Manifest::IntentFilter do
+    describe '.parse' do
+      subject { Android::Manifest::IntentFilter.parse(elem) }
+      context 'assings "action" element' do
+        let(:elem) { REXML::Element.new('action') }
+        it { should be_instance_of Android::Manifest::IntentFilter::Action }
+      end
+      context 'assings "category" element' do
+        let(:elem) { REXML::Element.new('category') }
+        it { should be_instance_of Android::Manifest::IntentFilter::Category }
+      end
+      context 'assings "data" element' do
+        let(:elem) { REXML::Element.new('data') }
+        it { should be_instance_of Android::Manifest::IntentFilter::Data }
+      end
+      context 'assings unknown element' do
+        let(:elem) { REXML::Element.new('unknown') }
+        it { should be_nil }
+      end
+    end
+  end
+
+  context "with stub AXMLParser" do
+    let(:dummy_xml) {
+      xml = REXML::Document.new
+      xml << REXML::Element.new('manifest')
+    }
+    let(:manifest) { Android::Manifest.new('mock data') }
+
+    before do
+      parser = stub(Android::AXMLParser, :parse => dummy_xml) 
+      Android::AXMLParser.stub(:new).and_return(parser)
+    end
+
+    describe "#use_parmissions" do
+      subject { manifest.use_permissions }
+      context "with valid 3 parmission elements" do
+        before do
+          3.times do |i|
+            elem = REXML::Element.new("uses-permission")
+            elem.add_attribute 'name', "permission#{i}"
+            dummy_xml.root << elem
+          end
+        end
+        it { subject.should have(3).items }
+        it "should have permissions" do
+          subject.should include("permission0")
+          subject.should include("permission1")
+          subject.should include("permission2")
+        end
+      end
+      context "with no parmissions" do
+        it { should be_empty }
+      end
+    end
+
+    describe "#components" do
+      subject { manifest.components }
+      context "with valid parmission element" do
+        before do
+          app = REXML::Element.new('application')
+          activity = REXML::Element.new('activity')
+          app << activity
+          dummy_xml.root << app
+        end
+        it "should have components" do
+          subject.should have(1).items
+        end
+        it "should returns Component object" do
+          subject[0].should be_kind_of Android::Manifest::Component
+        end
+      end
+      context "with no components" do
+        it { should be_empty }
+      end
+      context 'with text element in intent-filter element. (issue #3)' do 
+        before do
+          app = REXML::Element.new('application')
+          activity = REXML::Element.new('activity')
+          intent_filter = REXML::Element.new('intent-filter')
+          text = REXML::Text.new('sample')
+
+          intent_filter << text
+          activity << intent_filter
+          app << activity
+          dummy_xml.root << app
+        end
+        it "should have components" do
+          subject.should have(1).items
+        end
+        it { expect { subject }.to_not raise_error }
+      end
+    end
+  end
+
+  context "with real sample_AndroidManifest.xml data" do
+    let(:bin_xml_path){ File.expand_path(File.dirname(__FILE__) + '/data/sample_AndroidManifest.xml') }
+    let(:bin_xml){ File.open(bin_xml_path, 'rb') {|f| f.read } }
+    let(:manifest){ Android::Manifest.new(bin_xml) }
+
+    describe "#components" do
+      subject { manifest.components }
+      it { should be_kind_of Array }
+      it { subject[0].should be_kind_of Android::Manifest::Component }
+    end
+    describe "#package_name" do
+      subject { manifest.package_name }
+      it { should == "example.app.sample" }
+    end
+    describe "#version_code" do
+      subject { manifest.version_code}
+      it { should == 101 }
+    end
+    describe "#version_name" do
+      subject { manifest.version_name}
+      it { should == "1.0.1-malware2" }
+    end
+    describe "#min_sdk_ver" do
+      subject { manifest.min_sdk_ver}
+      it { should == 10 }
+    end
+    describe "#label" do
+      subject { manifest.label }
+      it { should == "@0x7f040001" }
+
+      context "with real apk file" do
+        let(:tmp_path){ File.expand_path(File.dirname(__FILE__) + '/data/sample.apk') }
+        let(:apk) { Android::Apk.new(tmp_path) }
+        let(:manifest){ apk.manifest }
+        subject { manifest.label }
+        it { should eq 'Sample' }
+        context 'when assign lang code' do
+          subject { manifest.label('ja') }
+          it { should eq 'Sample' }
+        end
+      end
+    end
+    describe "#doc" do
+      subject { manifest.doc }
+      it { should be_instance_of REXML::Document }
+    end
+    describe "#to_xml" do
+      let(:raw_xml){ str = <<EOS
+<manifest xmlns:android='http://schemas.android.com/apk/res/android' android:versionCode='101' android:versionName='1.0.1-malware2' package='example.app.sample'>
+    <uses-sdk android:minSdkVersion='10'/>
+    <uses-permission android:name='android.permission.INTERNET'/>
+    <uses-permission android:name='android.permission.WRITE_EXTERNAL_STORAGE'/>
+    <application android:label='@0x7f040001' android:icon='@0x7f020000' android:debuggable='true'>
+        <activity android:label='@0x7f040001' android:name='example.app.sample.SampleActivity'>
+            <intent-filter>
+                <action android:name='android.intent.action.MAIN'/>
+                <category android:name='android.intent.category.LAUNCHER'/>
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>
+EOS
+        str.strip
+      }
+
+      subject { manifest.to_xml }
+      it "should return correct xml string" do
+        subject.should == raw_xml
+      end
+    end
+  end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Android::Resource do
+  let(:res_data) { File.read(res_path) }
+  let(:resource) { Android::Resource.new(res_data) }
+
+  shared_examples_for 'a valid Android::Resource' do
+    subject { resource }
+    describe '#initialize' do
+      context 'assigns resources.arsc data' do
+        it { should be_instance_of Android::Resource }
+      end
+    end
+    its(:package_count) {should eq 1 }
+    describe '#strings' do
+      subject { resource.strings }
+      it { should have(7).items } # depends on sample_resources.arsc
+      it { should include 'Sample' }
+      it { should include 'Hello World, SampleActivity!' }
+      it { should include '日本語リソース' }
+    end
+  end
+  context 'with sample_resources.arsc data' do
+    let(:res_path) { File.expand_path(File.dirname(__FILE__) + '/data/sample_resources.arsc') }
+    it_behaves_like 'a valid Android::Resource'
+
+  end
+  context 'with sample_resources_utf16.arsc data' do
+    let(:res_path) { File.expand_path(File.dirname(__FILE__) + '/data/sample_resources_utf16.arsc') }
+    it_behaves_like 'a valid Android::Resource'
+  end
+
+  describe Android::Resource::ChunkHeader do
+    shared_examples_for 'a chunk header' do
+      its(:type) { should eq 20 }
+      its(:header_size) { should eq 244 }
+      its(:size) { should eq 1000 }
+    end
+    subject { Android::Resource::ChunkHeader.new(data, offset) }
+    context 'with no offset' do
+      let(:data) { "\x14\x00\xF4\x00\xE8\x03\x00\x00" } # [20, 244, 1000].pack('vvV')
+      let(:offset) { 0 }
+      it_behaves_like 'a chunk header'
+    end
+    context 'with 10byte offset' do
+      let(:data) { "\x00"*10 + "\x14\x00\xF4\x00\xE8\x03\x00\x00" } # [20, 244, 1000].pack('vvV')
+      let(:offset) { 10 }
+      it_behaves_like 'a chunk header'
+    end
+  end
+
+  describe Android::Resource::ResStringPool do
+    describe '.utf8_len' do
+      subject { Android::Resource::ResStringPool.utf8_len(data) }
+      context 'assigns 0x7F' do
+        let(:data) { "\x7f" }
+        it { should eq [0x7f, 1] }
+      end
+      context 'assigns x81x01' do
+        let(:data) { "\x81\x01" }
+        it { should eq [0x0101, 2] }
+      end
+      context 'assigns xffxff' do
+        let(:data) { "\xff\xff" }
+        it { should eq [0x7fff, 2] }
+      end
+    end
+    describe '#utf16_len' do
+      subject { Android::Resource::ResStringPool.utf16_len(data) }
+      context 'assigns x7fff' do
+        let(:data) { "\xff\x7f" }
+        it { should eq [0x7fff, 2] }
+      end
+      context 'assigns x8001,x0001' do
+        let(:data) { "\x01\x80\x01\x00" }
+        it { should eq [0x10001, 4] }
+      end
+      context 'assigns xffff,xffff' do
+        let(:data) { "\xff\xff\xff\xff" }
+        it 'should eq 0x7fff 0xffff' do
+          should eq [0x7fffffff, 4] 
+        end
+      end
+    end
+
+    context 'with str_resources.arsc data' do
+      let(:res_data) { File.read(File.expand_path(File.dirname(__FILE__) + '/data/str_resources.arsc')) }
+      subject { resource }
+      describe 'about drawable resource' do
+        it 'hoge' do
+          table = resource.packages.first[1]
+          p table
+          table.type_strings.each_with_index do |type, id|
+            puts "[0x#{(id+1).to_s(16)}] #{type}"
+          end
+          puts "readable id:" + table.res_readable_id('@0x7f020000')
+        end
+      end
+    end
+    context 'with str_resources.arsc data' do
+      let(:res_data) { File.read(File.expand_path(File.dirname(__FILE__) + '/data/str_resources.arsc')) }
+      subject { resource }
+      describe '#packages' do
+        subject {resource.packages}
+        it { should be_instance_of Hash}
+        it { subject.size.should eq 1 }
+      end
+      describe 'ResTablePackage' do
+        subject { resource.packages.first[1] }
+        it { subject.type(1).should eq 'attr' }
+        it { subject.type(4).should eq 'string' }
+        it { subject.name.should eq 'com.example.sample.ruby_apk' }
+      end
+      describe '#find' do
+        it '@0x7f040000 should return "sample.ruby_apk"' do
+          subject.find('@0x7f040000').should eq 'sample application'
+        end
+        it '@string/app_name should return "sample.ruby_apk"' do
+          subject.find('@string/app_name').should eq 'sample application'
+        end
+        it '@string/hello_world should return "Hello world!"' do
+          subject.find('@string/hello_world').should eq 'Hello world!'
+        end
+        it '@string/app_name should return "sample.ruby_apk"' do
+          subject.find('@string/app_name').should eq 'sample application'
+        end
+        it '@string/app_name with {:lang => "ja"} should return "サンプルアプリ"' do
+          subject.find('@string/app_name', :lang => 'ja').should eq 'サンプルアプリ'
+        end
+        it '@string/hello_world with {:lang => "ja"} should return nil' do
+          subject.find('@string/hello_world', :lang => 'ja').should be_nil
+        end
+        context 'assigns not exist string resource id' do
+          it {  expect {subject.find('@string/not_exist') }.to raise_error Android::NotFoundError }
+          it {  expect {subject.find('@0x7f040033') }.to raise_error Android::NotFoundError }
+        end
+        context 'assigns not string resource id' do
+          it { subject.find('@layout/activity_main').should be_nil }
+        end
+        context 'assigns invalid format id' do
+          it '"@xxyyxxyy" should raise ArgumentError' do
+            expect{ subject.find('@xxyyxxyy') }.to raise_error(ArgumentError)
+          end
+          it '"@0xff112233445566" should raise ArgumentError' do
+            expect{ subject.find('@0xff112233445566') }.to raise_error(ArgumentError) 
+          end
+        end
+      end
+      describe '#res_readable_id' do
+        it { subject.res_readable_id('@0x7f040000').should eq '@string/app_name' }
+        context 'assigns invalid type' do
+          it { expect{subject.res_readable_id('@0x7f0f0000')}.to raise_error Android::NotFoundError }
+        end
+        context 'assigns invalid key' do
+          it { expect{subject.res_readable_id('@0x7f040033')}.to raise_error Android::NotFoundError }
+        end
+      end
+      describe '#res_hex_id' do
+        it { subject.res_hex_id('@string/app_name').should eq '@0x7f040000' }
+        context 'assigns invalid type' do
+          it { expect{subject.res_readable_id('@not_exist/xxxx')}.to raise_error Android::NotFoundError }
+        end
+        context 'assigns invalid key' do
+          it { expect{subject.res_readable_id('@string/not_exist')}.to raise_error Android::NotFoundError }
+        end
+      end
+    end
+  end
+end

data/spec/ruby_apk_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "RubyApk" do
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/spec"
+end
+require 'rspec'
+require 'ruby_android'
+
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end