cloudsmith-api 0.21.4 → 0.30.7

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.18/spec/ffi/io_spec.rb

@@ -1,16 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-if false # disabled for #390
-  describe "FFI::IO.for_fd" do
-    it "produces an IO wrapping the specified file descriptor" do
-      expect do
-        FFI::IO.for_fd(2, "r")
-      end.to_not raise_error
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.18/spec/ffi/library_spec.rb

@@ -1,286 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe "Library" do
-  describe ".enum_value" do
-    m = Module.new do
-      extend FFI::Library
-      enum :something, [:one, :two]
-    end
-
-    it "should return a value for a valid key" do
-      expect(m.enum_value(:one)).to eq(0)
-      expect(m.enum_value(:two)).to eq(1)
-    end
-
-    it "should return nil for an invalid key" do
-      expect(m.enum_value(:three)).to be nil
-    end
-  end
-
-  describe "#ffi_convention" do
-    it "defaults to :default" do
-      m = Module.new do
-        extend FFI::Library
-      end
-      expect(m.ffi_convention).to eq(:default)
-    end
-
-    it "should be settable" do
-      m = Module.new do
-        extend FFI::Library
-      end
-
-      expect(m.ffi_convention).to eq(:default)
-      m.ffi_convention :stdcall
-      expect(m.ffi_convention).to eq(:stdcall)
-    end
-  end
-
-  if FFI::Platform::OS =~ /windows|cygwin/ && FFI::Platform::ARCH == 'i386'
-    module LibTestStdcall
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      ffi_convention :stdcall
-
-      class StructUCDP < FFI::Struct
-        layout :a1, :uchar,
-          :a2, :double,
-          :a3, :pointer
-      end
-
-      attach_function :testStdcallManyParams, [ :pointer, :int8, :int16, :int32, :int64,
-              StructUCDP.by_value, StructUCDP.by_ref, :float, :double ], :void
-    end
-
-    it "adds stdcall decoration: testStdcallManyParams@64" do
-      s = LibTestStdcall::StructUCDP.new
-      po = FFI::MemoryPointer.new :long
-      LibTestStdcall.testStdcallManyParams po, 1, 2, 3, 4, s, s, 1.0, 2.0
-    end
-  end
-
-  describe "ffi_lib" do
-    it "empty name list should raise error" do
-      expect {
-        Module.new do |m|
-          m.extend FFI::Library
-          ffi_lib
-        end
-      }.to raise_error(LoadError)
-    end
-    
-  end
-
-  unless RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
-    it "attach_function with no library specified" do
-      expect {
-        Module.new do |m|
-          m.extend FFI::Library
-          attach_function :getpid, [ ], :uint
-        end
-      }.to raise_error
-    end
-
-    it "attach_function :getpid from this process" do
-      expect {
-        expect(Module.new do |m|
-          m.extend FFI::Library
-          ffi_lib FFI::Library::CURRENT_PROCESS
-          attach_function :getpid, [ ], :uint
-        end.getpid).to eq(Process.pid)
-      }.not_to raise_error
-    end
-
-    it "loads library using symbol" do
-      expect {
-        expect(Module.new do |m|
-          m.extend FFI::Library
-          ffi_lib :c
-          attach_function :getpid, [ ], :uint
-        end.getpid).to eq(Process.pid)
-      }.not_to raise_error
-    end
-
-    it "attach_function :getpid from [ 'c', 'libc.so.6'] " do
-      expect {
-        expect(Module.new do |m|
-          m.extend FFI::Library
-          ffi_lib [ 'c', 'libc.so.6' ]
-          attach_function :getpid, [ ], :uint
-        end.getpid).to eq(Process.pid)
-      }.not_to raise_error
-    end
-
-    it "attach_function :getpid from [ 'libc.so.6', 'c' ] " do
-      expect {
-        expect(Module.new do |m|
-          m.extend FFI::Library
-          ffi_lib [ 'libc.so.6', 'c' ]
-          attach_function :getpid, [ ], :uint
-        end.getpid).to eq(Process.pid)
-      }.not_to raise_error
-    end
-
-    it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef', nil, 'c' ] " do
-      expect {
-        expect(Module.new do |m|
-          m.extend FFI::Library
-          ffi_lib [ 'libfubar.so.0xdeadbeef', nil, 'c' ]
-          attach_function :getpid, [ ], :uint
-        end.getpid).to eq(Process.pid)
-      }.not_to raise_error
-    end
-
-    it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef' ] " do
-      expect {
-        expect(Module.new do |m|
-          m.extend FFI::Library
-          ffi_lib 'libfubar.so.0xdeadbeef'
-          attach_function :getpid, [ ], :uint
-        end.getpid).to eq(Process.pid)
-      }.to raise_error(LoadError)
-    end
-
-    it "attach_function :bool_return_true from [ File.expand_path(#{TestLibrary::PATH.inspect}) ]" do
-      mod = Module.new do |m|
-        m.extend FFI::Library
-        ffi_lib File.expand_path(TestLibrary::PATH)
-        attach_function :bool_return_true, [ ], :bool
-      end
-      expect(mod.bool_return_true).to be true
-    end
-  end
-
-  def gvar_lib(name, type)
-    Module.new do |m|
-      m.extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      attach_variable :gvar, "gvar_#{name}", type
-      attach_function :get, "gvar_#{name}_get", [], type
-      attach_function :set, "gvar_#{name}_set", [ type ], :void
-    end
-  end
-
-  def gvar_test(name, type, val)
-    lib = gvar_lib(name, type)
-    lib.set(val)
-    expect(lib.gvar).to eq(val)
-    lib.set(0)
-    lib.gvar = val
-    expect(lib.get).to eq(val)
-  end
-
-  [ 0, 127, -128, -1 ].each do |i|
-    it ":char variable" do
-      gvar_test("s8", :char, i)
-    end
-  end
-
-  [ 0, 0x7f, 0x80, 0xff ].each do |i|
-    it ":uchar variable" do
-      gvar_test("u8", :uchar, i)
-    end
-  end
-
-  [ 0, 0x7fff, -0x8000, -1 ].each do |i|
-    it ":short variable" do
-      gvar_test("s16", :short, i)
-    end
-  end
-
-  [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
-    it ":ushort variable" do
-      gvar_test("u16", :ushort, i)
-    end
-  end
-
-  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
-    it ":int variable" do
-      gvar_test("s32", :int, i)
-    end
-  end
-
-  [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
-    it ":uint variable" do
-      gvar_test("u32", :uint, i)
-    end
-  end
-
-  [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
-    it ":long_long variable" do
-      gvar_test("s64", :long_long, i)
-    end
-  end
-
-  [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
-    it ":ulong_long variable" do
-      gvar_test("u64", :ulong_long, i)
-    end
-  end
-
-  if FFI::Platform::LONG_SIZE == 32
-    [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
-      it ":long variable" do
-        gvar_test("long", :long, i)
-      end
-    end
-
-    [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
-      it ":ulong variable" do
-        gvar_test("ulong", :ulong, i)
-      end
-    end
-  else
-    [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
-      it ":long variable" do
-        gvar_test("long", :long, i)
-      end
-    end
-
-    [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
-      it ":ulong variable" do
-        gvar_test("ulong", :ulong, i)
-      end
-    end
-  end
-
-  it "Pointer variable" do
-    lib = gvar_lib("pointer", :pointer)
-    val = FFI::MemoryPointer.new :long
-    lib.set(val)
-    expect(lib.gvar).to eq(val)
-    lib.set(nil)
-    lib.gvar = val
-    expect(lib.get).to eq(val)
-  end
-
-  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
-    it "structure" do
-      class GlobalStruct < FFI::Struct
-        layout :data, :long
-      end
-
-      lib = Module.new do |m|
-        m.extend FFI::Library
-        ffi_lib TestLibrary::PATH
-        attach_variable :gvar, "gvar_gstruct", GlobalStruct
-        attach_function :get, "gvar_gstruct_get", [], GlobalStruct
-        attach_function :set, "gvar_gstruct_set", [ GlobalStruct ], :void
-      end
-
-      val = GlobalStruct.new
-      val[:data] = i
-      lib.set(val)
-      expect(lib.gvar[:data]).to eq(i)
-      val[:data] = 0
-      lib.gvar[:data] = i
-      val = GlobalStruct.new(lib.get)
-      expect(val[:data]).to eq(i)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.18/spec/ffi/long_double.rb

@@ -1,30 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'bigdecimal'
-
-describe ":long_double arguments and return values" do
-  module LibTest
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    attach_function :add_f128, [ :long_double, :long_double ], :long_double
-    attach_function :ret_f128, [ :long_double ], :long_double
-  end
-
-  it "returns first parameter" do
-    expect(LibTest.ret_f128(0.1)).to be_within(0.01).of(0.1)
-  end
-
-  it "returns first parameter with high precision" do
-    ld =        BigDecimal.new("1.234567890123456789")
-    tolerance = BigDecimal.new("0.0000000000000000001")
-    expect(LibTest.ret_f128(ld)).to be_within(tolerance).of(ld)
-  end
-
-  it "add two long double numbers" do
-    expect(LibTest.add_f128(0.1, 0.2)).to be_within(0.01).of(0.3)
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.18/spec/ffi/managed_struct_spec.rb

@@ -1,68 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe "Managed Struct" do
-  include FFI
-  module ManagedStructTestLib
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
-  end
-
-  it "should raise an error if release() is not defined" do
-    class NoRelease < FFI::ManagedStruct ; layout :i, :int; end
-    expect { NoRelease.new(ManagedStructTestLib.ptr_from_address(0x12345678)) }.to raise_error(NoMethodError)
-  end
-
-  it "should be the right class" do
-    class WhatClassAmI < FFI::ManagedStruct
-      layout :i, :int
-      def self.release
-      end
-    end    
-
-    expect(WhatClassAmI.new(ManagedStructTestLib.ptr_from_address(0x12345678)).class).to eq(WhatClassAmI)
-  end
-
-  it "should build with self reference" do
-    class ClassWithSelfRef < FFI::ManagedStruct
-      layout :data, self.ptr
-      def self.release
-      end
-    end
-
-    expect(ClassWithSelfRef.new(ManagedStructTestLib.ptr_from_address(0x12345678)).class).to eq(ClassWithSelfRef)
-  end
-
-  # see #427
-  it "should release memory properly", :broken => true do
-    class PleaseReleaseMe < FFI::ManagedStruct
-      layout :i, :int
-      @@count = 0
-      def self.release
-        @@count += 1
-      end
-      def self.wait_gc(count)
-        loop = 5
-        while loop > 0 && @@count < count
-          loop -= 1
-          TestLibrary.force_gc
-          sleep 0.05 if @@count < count
-        end
-      end
-    end
-
-    loop_count = 30
-    wiggle_room = 5
-
-    expect(PleaseReleaseMe).to receive(:release).at_least(loop_count-wiggle_room).times
-    loop_count.times do
-      PleaseReleaseMe.new(ManagedStructTestLib.ptr_from_address(0x12345678))
-    end
-    PleaseReleaseMe.wait_gc loop_count
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.18/spec/ffi/memorypointer_spec.rb

@@ -1,78 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-MemoryPointer = FFI::MemoryPointer
-
-describe "MemoryPointer#total" do
-  it "MemoryPointer.new(:char, 1).total == 1" do
-    expect(MemoryPointer.new(:char, 1).total).to eq 1
-  end
-
-  it "MemoryPointer.new(:short, 1).total == 2" do
-    expect(MemoryPointer.new(:short, 1).total).to eq 2
-  end
-
-  it "MemoryPointer.new(:int, 1).total == 4" do
-    expect(MemoryPointer.new(:int, 1).total).to eq 4
-  end
-
-  it "MemoryPointer.new(:long_long, 1).total == 8" do
-    expect(MemoryPointer.new(:long_long, 1).total).to eq 8
-  end
-
-  it "MemoryPointer.new(1024).total == 1024" do
-    expect(MemoryPointer.new(1024).total).to eq 1024
-  end
-end
-describe "MemoryPointer#read_array_of_long" do
-  it "foo" do
-    ptr = MemoryPointer.new(:long, 1024)
-    ptr[0].write_long 1234
-    ptr[1].write_long 5678
-    l = ptr.read_array_of_long(2)
-    expect(l[0]).to eq 1234
-    expect(l[1]).to eq 5678
-  end
-end
-describe "MemoryPointer argument" do
-  module Ptr
-    extend FFI::Library
-    ffi_lib FFI::Platform::LIBC
-    attach_function :memset, [ :pointer, :int, :ulong ], :pointer
-    attach_function :memcpy, [ :pointer, :pointer, :ulong ], :pointer
-  end
-
-  it "Pointer passed correctly" do
-    p = MemoryPointer.new :int, 1
-    ret = Ptr.memset(p, 0, p.total)
-    expect(ret).to eq p
-  end
-
-  it "Data passed to native function" do
-    p = MemoryPointer.new :int, 1
-    p2 = MemoryPointer.new :int, 1
-    p2.put_int(0, 0x5eadbeef)
-    Ptr.memcpy(p, p2, p.total)
-    expect(p.get_int(0)).to eq p2.get_int(0)
-    expect(p2.get_int(0)).not_to eql 0
-  end
-end
-describe "MemoryPointer return value" do
-  module Stdio
-    extend FFI::Library
-    ffi_lib FFI::Platform::LIBC
-    attach_function :fopen, [ :string, :string ], :pointer
-    attach_function :fclose, [ :pointer ], :int
-    attach_function :fwrite, [ :pointer, :ulong, :ulong, :string ], :ulong
-  end
-
-  it "fopen returns non-nil" do
-    fp = Stdio.fopen("/dev/null", "w")
-    expect(fp).to_not be_nil
-    expect(Stdio.fclose(fp)).to  eq 0 unless fp.nil? or fp.null? 
-  end
-end