contrast-agent 3.9.1 → 6.15.3

data/resources/ruby-spec/parameters_spec.rb

@@ -1,261 +0,0 @@
-require_relative '../../spec_helper'
-require_relative 'fixtures/classes'
-
-describe "Method#parameters" do
-  class MethodSpecs::Methods
-    def one_key(a: 1); end
-    def one_keyrest(**a); end
-
-    def one_keyreq(a:); end
-
-    def one_splat_one_req(*a,b); end
-    def one_splat_two_req(*a,b,c); end
-    def one_splat_one_req_with_block(*a,b,&blk); end
-
-    def one_opt_with_stabby(a=-> b { true }); end
-
-    def one_unnamed_splat(*); end
-
-    def one_splat_one_block(*args, &block)
-      local_is_not_parameter = {}
-    end
-
-    define_method(:one_optional_defined_method) {|x = 1|}
-  end
-
-  it "returns an empty Array when the method expects no arguments" do
-    MethodSpecs::Methods.instance_method(:zero).parameters.should == []
-  end
-
-  it "returns [[:req,:name]] for a method expecting one required argument called 'name'" do
-    MethodSpecs::Methods.instance_method(:one_req).parameters.should == [[:req,:a]]
-  end
-
-  it "returns [[:req,:a],[:req,:b]] for a method expecting two required arguments called 'a' and 'b''" do
-    m = MethodSpecs::Methods.instance_method(:two_req)
-    m.parameters.should == [[:req,:a], [:req,:b]]
-  end
-
-  it "returns [[:block,:blk]] for a method expecting one block argument called 'a'" do
-    m = MethodSpecs::Methods.instance_method(:zero_with_block)
-    m.parameters.should == [[:block,:blk]]
-  end
-
-  it "returns [[:req,:a],[:block,:b] for a method expecting a required argument ('a') and a block argument ('b')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_with_block)
-    m.parameters.should == [[:req,:a], [:block,:blk]]
-  end
-
-  it "returns [[:req,:a],[:req,:b],[:block,:c] for a method expecting two required arguments ('a','b') and a block argument ('c')" do
-    m = MethodSpecs::Methods.instance_method(:two_req_with_block)
-    m.parameters.should == [[:req,:a], [:req,:b], [:block,:blk]]
-  end
-
-  it "returns [[:opt,:a]] for a method expecting one optional argument ('a')" do
-    m = MethodSpecs::Methods.instance_method(:one_opt)
-    m.parameters.should == [[:opt,:a]]
-  end
-
-  it "returns [[:req,:a],[:opt,:b]] for a method expecting one required argument ('a') and one optional argument ('b')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_one_opt)
-    m.parameters.should == [[:req,:a],[:opt,:b]]
-  end
-
-  it "returns [[:req,:a],[:opt,:b]] for a method expecting one required argument ('a') and one optional argument ('b')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_one_opt)
-    m.parameters.should == [[:req,:a],[:opt,:b]]
-  end
-
-  it "returns [[:req,:a],[:opt,:b],[:opt,:c]] for a method expecting one required argument ('a') and two optional arguments ('b','c')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_two_opt)
-    m.parameters.should == [[:req,:a],[:opt,:b],[:opt,:c]]
-  end
-
-  it "returns [[:req,:a],[:req,:b],[:opt,:c]] for a method expecting two required arguments ('a','b') and one optional arguments ('c')" do
-    m = MethodSpecs::Methods.instance_method(:two_req_one_opt)
-    m.parameters.should == [[:req,:a],[:req,:b],[:opt,:c]]
-  end
-
-  it "returns [[:opt,:a],[:block,:b]] for a method expecting one required argument ('a') and one block argument ('b')" do
-    m = MethodSpecs::Methods.instance_method(:one_opt_with_block)
-    m.parameters.should == [[:opt,:a],[:block,:blk]]
-  end
-
-  it "returns [[:req,:a],[:opt,:b],[:block,:c]] for a method expecting one required argument ('a'), one optional argument ('b'), and a block ('c')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_one_opt_with_block)
-    m.parameters.should == [[:req,:a],[:opt,:b],[:block,:blk]]
-  end
-
-  it "returns [[:req,:a],[:opt,:b],[:opt,:c],[:block,:d]] for a method expecting one required argument ('a'), two optional arguments ('b','c'), and a block ('d')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_two_opt_with_block)
-    m.parameters.should == [[:req,:a],[:opt,:b],[:opt,:c],[:block,:blk]]
-  end
-
-  it "returns [[:rest,:a]] for a method expecting a single splat argument ('a')" do
-    m = MethodSpecs::Methods.instance_method(:zero_with_splat)
-    m.parameters.should == [[:rest,:a]]
-  end
-
-  it "returns [[:req,:a],[:rest,:b]] for a method expecting a splat argument ('a') and a required argument ('b')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_with_splat)
-    m.parameters.should == [[:req,:a],[:rest,:b]]
-  end
-
-  it "returns [[:req,:a],[:req,:b],[:rest,:c]] for a method expecting two required arguments ('a','b') and a splat argument ('c')" do
-    m = MethodSpecs::Methods.instance_method(:two_req_with_splat)
-    m.parameters.should == [[:req,:a],[:req,:b],[:rest,:c]]
-  end
-
-  it "returns [[:req,:a],[:opt,:b],[:rest,:c]] for a method expecting a required argument ('a','b'), an optional argument ('b'), and a splat argument ('c')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_one_opt_with_splat)
-    m.parameters.should == [[:req,:a],[:opt,:b],[:rest,:c]]
-  end
-
-  it "returns [[:req,:a],[:req,:b],[:opt,:b],[:rest,:d]] for a method expecting two required arguments ('a','b'), an optional argument ('c'), and a splat argument ('d')" do
-    m = MethodSpecs::Methods.instance_method(:two_req_one_opt_with_splat)
-    m.parameters.should == [[:req,:a],[:req,:b],[:opt,:c],[:rest,:d]]
-  end
-
-  it "returns [[:req,:a],[:opt,:b],[:opt,:c],[:rest,:d]] for a method expecting a required argument ('a'), two optional arguments ('b','c'), and a splat argument ('d')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_two_opt_with_splat)
-    m.parameters.should == [[:req,:a],[:opt,:b],[:opt,:c],[:rest,:d]]
-  end
-
-  it "returns [[:rest,:a],[:block,:b]] for a method expecting a splat argument ('a') and a block argument ('b')" do
-    m = MethodSpecs::Methods.instance_method(:zero_with_splat_and_block)
-    m.parameters.should == [[:rest,:a],[:block,:blk]]
-  end
-
-  it "returns [[:req,:a],[:rest,:b],[:block,:c]] for a method expecting a required argument ('a'), a splat argument ('b'), and a block ('c')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_with_splat_and_block)
-    m.parameters.should == [[:req,:a],[:rest,:b],[:block,:blk]]
-  end
-
-  it "returns [[:req,:a],[:req,:b],[:rest,:c],[:block,:d]] for a method expecting two required arguments ('a','b'), a splat argument ('c'), and a block ('d')" do
-    m = MethodSpecs::Methods.instance_method(:two_req_with_splat_and_block)
-    m.parameters.should == [[:req,:a],[:req,:b],[:rest,:c],[:block,:blk]]
-  end
-
-  it "returns [[:req,:a],[:opt,:b],[:rest,:c],[:block,:d]] for a method expecting a required argument ('a'), a splat argument ('c'), and a block ('d')" do
-    m = MethodSpecs::Methods.instance_method(:one_req_one_opt_with_splat_and_block)
-    m.parameters.should == [[:req,:a],[:opt,:b],[:rest,:c],[:block,:blk]]
-  end
-
-  it "returns [[:req,:a],[:req,:b],[:opt,:c],[:block,:d]] for a method expecting two required arguments ('a','b'), an optional argument ('c'), a splat argument ('d'), and a block ('e')" do
-    m = MethodSpecs::Methods.instance_method(:two_req_one_opt_with_splat_and_block)
-    m.parameters.should == [[:req,:a],[:req,:b],[:opt,:c],[:rest,:d],[:block,:blk]]
-  end
-
-  it "returns [[:rest,:a],[:req,:b]] for a method expecting a splat argument ('a') and a required argument ('b')" do
-    m = MethodSpecs::Methods.instance_method(:one_splat_one_req)
-    m.parameters.should == [[:rest,:a],[:req,:b]]
-  end
-
-  it "returns [[:rest,:a],[:req,:b],[:req,:c]] for a method expecting a splat argument ('a') and two required arguments ('b','c')" do
-    m = MethodSpecs::Methods.instance_method(:one_splat_two_req)
-    m.parameters.should == [[:rest,:a],[:req,:b],[:req,:c]]
-  end
-
-  it "returns [[:rest,:a],[:req,:b],[:block,:c]] for a method expecting a splat argument ('a'), a required argument ('b'), and a block ('c')" do
-    m = MethodSpecs::Methods.instance_method(:one_splat_one_req_with_block)
-    m.parameters.should == [[:rest,:a],[:req,:b],[:block,:blk]]
-  end
-
-  it "returns [[:key,:a]] for a method with a single optional keyword argument" do
-    m = MethodSpecs::Methods.instance_method(:one_key)
-    m.parameters.should == [[:key,:a]]
-  end
-
-  it "returns [[:keyrest,:a]] for a method with a keyword rest argument" do
-    m = MethodSpecs::Methods.instance_method(:one_keyrest)
-    m.parameters.should == [[:keyrest,:a]]
-  end
-
-  it "returns [[:keyreq,:a]] for a method with a single required keyword argument" do
-    m = MethodSpecs::Methods.instance_method(:one_keyreq)
-    m.parameters.should == [[:keyreq,:a]]
-  end
-
-  it "works with ->(){} as the value of an optional argument" do
-    m = MethodSpecs::Methods.instance_method(:one_opt_with_stabby)
-    m.parameters.should == [[:opt,:a]]
-  end
-
-  # define_method variants
-  it "returns [] for a define_method method with explicit no-args || specification" do
-    m = MethodSpecs::Methods.instance_method(:zero_defined_method)
-    m.parameters.should == []
-  end
-
-  it "returns [[:rest, :x]] for a define_method method with rest arg 'x' only" do
-    m = MethodSpecs::Methods.instance_method(:zero_with_splat_defined_method)
-    m.parameters.should == [[:rest, :x]]
-  end
-
-  it "returns [[:req, :x]] for a define_method method expecting one required argument 'x'" do
-    m = MethodSpecs::Methods.instance_method(:one_req_defined_method)
-    m.parameters.should == [[:req, :x]]
-  end
-
-  it "returns [[:req, :x], [:req, :y]] for a define_method method expecting two required arguments 'x' and 'y'" do
-    m = MethodSpecs::Methods.instance_method(:two_req_defined_method)
-    m.parameters.should == [[:req, :x], [:req, :y]]
-  end
-
-  it "returns [] for a define_method method with no args specification" do
-    m = MethodSpecs::Methods.instance_method(:no_args_defined_method)
-    m.parameters.should == []
-  end
-
-  it "returns [[:req]] for a define_method method with a grouping as its only argument" do
-    m = MethodSpecs::Methods.instance_method(:two_grouped_defined_method)
-    m.parameters.should == [[:req]]
-  end
-
-  it "returns [[:opt, :x]] for a define_method method with an optional argument 'x'" do
-    m = MethodSpecs::Methods.instance_method(:one_optional_defined_method)
-    m.parameters.should == [[:opt, :x]]
-  end
-
-  it "returns [[:rest]] for a Method generated by respond_to_missing?" do
-    m = MethodSpecs::Methods.new
-    m.method(:handled_via_method_missing).parameters.should == [[:rest]]
-  end
-
-  it "adds nameless rest arg for \"star\" argument" do
-    m = MethodSpecs::Methods.new
-    m.method(:one_unnamed_splat).parameters.should == [[:rest]]
-  end
-
-  it "returns the args and block for a splat and block argument" do
-    m = MethodSpecs::Methods.new
-    m.method(:one_splat_one_block).parameters.should == [[:rest, :args], [:block, :block]]
-  end
-
-  it "returns [] for a Method generated by attr_reader" do
-    m = MethodSpecs::Methods.new
-    m.method(:reader).parameters.should == []
-  end
-
-  it "return [[:req]] for a Method generated by attr_writer" do
-    m = MethodSpecs::Methods.new
-    m.method(:writer=).parameters.should == [[:req]]
-  end
-
-  it "returns [[:rest]] for core methods with variable-length argument lists" do
-    # delete! takes rest args
-    "foo".method(:delete!).parameters.should == [[:rest]]
-  end
-
-  it "returns [[:rest]] or [[:opt]] for core methods with optional arguments" do
-    # pop takes 1 optional argument
-    [
-        [[:rest]],
-        [[:opt]]
-    ].should include([].method(:pop).parameters)
-  end
-
-  it "returns [[:req]] for each parameter for core methods with fixed-length argument lists" do
-    'foo'.method('cs__patched_string_+'.to_sym).parameters.should == [[:req]] # REASON: ADDING PATCH CHANGES THIS
-  end
-end

data/resources/ruby-spec/ruby_spec_spec_helper.rb

@@ -1,35 +0,0 @@
-use_realpath = File.respond_to?(:realpath)
-root = File.dirname(__FILE__)
-dir = 'fixtures/code'
-CODE_LOADING_DIR ||= use_realpath ? File.realpath(dir, root) : File.expand_path(dir, root)
-require 'json'
-require 'contrast-agent'
-Contrast::Agent::Patching::Policy::Patcher.patch_methods
-
-# Enable Thread.report_on_exception by default to catch thread errors earlier
-if Thread.respond_to? :report_on_exception=
-  Thread.report_on_exception = true
-else
-  class Thread
-    def report_on_exception=(value)
-      raise 'shim Thread#report_on_exception used with true' if value
-    end
-  end
-end
-
-# Running directly with ruby some_spec.rb
-unless ENV['MSPEC_RUNNER']
-  mspec_lib = File.expand_path('../../mspec/lib', __FILE__)
-  $LOAD_PATH << mspec_lib if File.directory?(mspec_lib)
-
-  begin
-    require 'mspec'
-    require 'mspec/commands/mspec-run'
-  rescue LoadError
-    puts 'Please add -Ipath/to/mspec/lib or clone mspec as a sibling to run the specs.'
-    exit 1
-  end
-
-  ARGV.unshift $0
-  MSpecRun.main
-end

data/service_executables/VERSION

@@ -1 +0,0 @@
-2.6.2

data/shared_libraries/funchook.h

@@ -1,123 +0,0 @@
-/*
- * This file is part of Funchook.
- * https://github.com/kubo/funchook
- *
- * Funchook is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 2 of the License, or (at your
- * option) any later version.
- *
- * As a special exception, the copyright holders of this library give you
- * permission to link this library with independent modules to produce an
- * executable, regardless of the license terms of these independent
- * modules, and to copy and distribute the resulting executable under
- * terms of your choice, provided that you also meet, for each linked
- * independent module, the terms and conditions of the license of that
- * module. An independent module is a module which is not derived from or
- * based on this library. If you modify this library, you may extend this
- * exception to your version of the library, but you are not obliged to
- * do so. If you do not wish to do so, delete this exception statement
- * from your version.
- *
- * Funchook is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Funchook. If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef FUNCHOOK_H
-#define FUNCHOOK_H 1
-
-/*
- * Only functions with FUNCHOOK_EXPORT are visible from outside of funchook.dll
- * or libfunchook.so. Others are invisible.
- */
-#ifdef WIN32
-#ifdef FUNCHOOK_EXPORTS
-#define FUNCHOOK_EXPORT __declspec(dllexport)
-#else /* FUNCHOOK_EXPORTS */
-#define FUNCHOOK_EXPORT __declspec(dllimport)
-#endif /* FUNCHOOK_EXPORTS */
-#elif defined(__GNUC__)
-#define FUNCHOOK_EXPORT __attribute__((visibility("default")))
-#else
-#define FUNCHOOK_EXPORT
-#endif /* WIN32 */
-
-typedef struct funchook funchook_t;
-
-#define FUNCHOOK_ERROR_INTERNAL_ERROR         -1
-#define FUNCHOOK_ERROR_SUCCESS                 0
-#define FUNCHOOK_ERROR_OUT_OF_MEMORY           1
-#define FUNCHOOK_ERROR_ALREADY_INSTALLED       2
-#define FUNCHOOK_ERROR_DISASSEMBLY             3
-#define FUNCHOOK_ERROR_IP_RELATIVE_OFFSET      4
-#define FUNCHOOK_ERROR_CANNOT_FIX_IP_RELATIVE  5
-#define FUNCHOOK_ERROR_FOUND_BACK_JUMP         6
-#define FUNCHOOK_ERROR_TOO_SHORT_INSTRUCTIONS  7
-#define FUNCHOOK_ERROR_MEMORY_ALLOCATION       8 /* memory allocation error */
-#define FUNCHOOK_ERROR_MEMORY_FUNCTION         9 /* other memory function errors */
-#define FUNCHOOK_ERROR_NOT_INSTALLED          10
-
-/**
- * Create a funchook handle
- *
- * @return allocated funchook handle. NULL when out-of-memory.
- */
-FUNCHOOK_EXPORT funchook_t *funchook_create(void);
-
-/**
- * Prepare hooking
- *
- * @param funchook     a funchook handle created by funchook_create()
- * @param target_func  function pointer to be intercepted. The pointer to trampoline function is set on success.
- * @param hook_func    function pointer which is called istead of target_func
- * @return             error code. one of FUNCHOOK_ERROR_*.
- */
-FUNCHOOK_EXPORT int funchook_prepare(funchook_t *funchook, void **target_func, void *hook_func);
-
-/**
- * Install hooks prepared by funchook_prepare().
- *
- * @param funchook     a funchook handle created by funchook_create()
- * @param flags        reserved. Set zero.
- * @return             error code. one of FUNCHOOK_ERROR_*.
- */
-FUNCHOOK_EXPORT int funchook_install(funchook_t *funchook, int flags);
-
-/**
- * Uninstall hooks installed by funchook_install().
- *
- * @param funchook     a funchook handle created by funchook_create()
- * @param flags        reserved. Set zero.
- * @return             error code. one of FUNCHOOK_ERROR_*.
- */
-FUNCHOOK_EXPORT int funchook_uninstall(funchook_t *funchook, int flags);
-
-/**
- * Destroy a funchook handle
- *
- * @param funchook     a funchook handle created by funchook_create()
- * @return             error code. one of FUNCHOOK_ERROR_*.
- */
-FUNCHOOK_EXPORT int funchook_destroy(funchook_t *funchook);
-
-/**
- * Get error message
- *
- * @param funchook     a funchook handle created by funchook_create()
- * @return             pointer to buffer containing error message
- */
-FUNCHOOK_EXPORT const char *funchook_error_message(const funchook_t *funchook);
-
-/**
- * Set log file name to debug funchook itself.
- *
- * @param name         log file name
- * @return             error code. one of FUNCHOOK_ERROR_*.
- */
-FUNCHOOK_EXPORT int funchook_set_debug_file(const char *name);
-
-#endif