arkpar
10 years ago
82 changed files with 4369 additions and 2180 deletions
@ -0,0 +1,161 @@ |
|||
#.rst: |
|||
# CMakeParseArguments |
|||
# ------------------- |
|||
# |
|||
# |
|||
# |
|||
# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords> |
|||
# <multi_value_keywords> args...) |
|||
# |
|||
# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions |
|||
# for parsing the arguments given to that macro or function. It |
|||
# processes the arguments and defines a set of variables which hold the |
|||
# values of the respective options. |
|||
# |
|||
# The <options> argument contains all options for the respective macro, |
|||
# i.e. keywords which can be used when calling the macro without any |
|||
# value following, like e.g. the OPTIONAL keyword of the install() |
|||
# command. |
|||
# |
|||
# The <one_value_keywords> argument contains all keywords for this macro |
|||
# which are followed by one value, like e.g. DESTINATION keyword of the |
|||
# install() command. |
|||
# |
|||
# The <multi_value_keywords> argument contains all keywords for this |
|||
# macro which can be followed by more than one value, like e.g. the |
|||
# TARGETS or FILES keywords of the install() command. |
|||
# |
|||
# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the |
|||
# keywords listed in <options>, <one_value_keywords> and |
|||
# <multi_value_keywords> a variable composed of the given <prefix> |
|||
# followed by "_" and the name of the respective keyword. These |
|||
# variables will then hold the respective value from the argument list. |
|||
# For the <options> keywords this will be TRUE or FALSE. |
|||
# |
|||
# All remaining arguments are collected in a variable |
|||
# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see |
|||
# whether your macro was called with unrecognized parameters. |
|||
# |
|||
# As an example here a my_install() macro, which takes similar arguments |
|||
# as the real install() command: |
|||
# |
|||
# :: |
|||
# |
|||
# function(MY_INSTALL) |
|||
# set(options OPTIONAL FAST) |
|||
# set(oneValueArgs DESTINATION RENAME) |
|||
# set(multiValueArgs TARGETS CONFIGURATIONS) |
|||
# cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}" |
|||
# "${multiValueArgs}" ${ARGN} ) |
|||
# ... |
|||
# |
|||
# |
|||
# |
|||
# Assume my_install() has been called like this: |
|||
# |
|||
# :: |
|||
# |
|||
# my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub) |
|||
# |
|||
# |
|||
# |
|||
# After the cmake_parse_arguments() call the macro will have set the |
|||
# following variables: |
|||
# |
|||
# :: |
|||
# |
|||
# MY_INSTALL_OPTIONAL = TRUE |
|||
# MY_INSTALL_FAST = FALSE (this option was not used when calling my_install() |
|||
# MY_INSTALL_DESTINATION = "bin" |
|||
# MY_INSTALL_RENAME = "" (was not used) |
|||
# MY_INSTALL_TARGETS = "foo;bar" |
|||
# MY_INSTALL_CONFIGURATIONS = "" (was not used) |
|||
# MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL" |
|||
# |
|||
# |
|||
# |
|||
# You can then continue and process these variables. |
|||
# |
|||
# Keywords terminate lists of values, e.g. if directly after a |
|||
# one_value_keyword another recognized keyword follows, this is |
|||
# interpreted as the beginning of the new option. E.g. |
|||
# my_install(TARGETS foo DESTINATION OPTIONAL) would result in |
|||
# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION |
|||
# would be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor. |
|||
|
|||
#============================================================================= |
|||
# Copyright 2010 Alexander Neundorf <neundorf@kde.org> |
|||
# |
|||
# Distributed under the OSI-approved BSD License (the "License"); |
|||
# see accompanying file Copyright.txt for details. |
|||
# |
|||
# This software is distributed WITHOUT ANY WARRANTY; without even the |
|||
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|||
# See the License for more information. |
|||
#============================================================================= |
|||
# (To distribute this file outside of CMake, substitute the full |
|||
# License text for the above reference.) |
|||
|
|||
|
|||
if(__CMAKE_PARSE_ARGUMENTS_INCLUDED) |
|||
return() |
|||
endif() |
|||
set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE) |
|||
|
|||
|
|||
function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames) |
|||
# first set all result variables to empty/FALSE |
|||
foreach(arg_name ${_singleArgNames} ${_multiArgNames}) |
|||
set(${prefix}_${arg_name}) |
|||
endforeach() |
|||
|
|||
foreach(option ${_optionNames}) |
|||
set(${prefix}_${option} FALSE) |
|||
endforeach() |
|||
|
|||
set(${prefix}_UNPARSED_ARGUMENTS) |
|||
|
|||
set(insideValues FALSE) |
|||
set(currentArgName) |
|||
|
|||
# now iterate over all arguments and fill the result variables |
|||
foreach(currentArg ${ARGN}) |
|||
list(FIND _optionNames "${currentArg}" optionIndex) # ... then this marks the end of the arguments belonging to this keyword |
|||
list(FIND _singleArgNames "${currentArg}" singleArgIndex) # ... then this marks the end of the arguments belonging to this keyword |
|||
list(FIND _multiArgNames "${currentArg}" multiArgIndex) # ... then this marks the end of the arguments belonging to this keyword |
|||
|
|||
if(${optionIndex} EQUAL -1 AND ${singleArgIndex} EQUAL -1 AND ${multiArgIndex} EQUAL -1) |
|||
if(insideValues) |
|||
if("${insideValues}" STREQUAL "SINGLE") |
|||
set(${prefix}_${currentArgName} ${currentArg}) |
|||
set(insideValues FALSE) |
|||
elseif("${insideValues}" STREQUAL "MULTI") |
|||
list(APPEND ${prefix}_${currentArgName} ${currentArg}) |
|||
endif() |
|||
else() |
|||
list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg}) |
|||
endif() |
|||
else() |
|||
if(NOT ${optionIndex} EQUAL -1) |
|||
set(${prefix}_${currentArg} TRUE) |
|||
set(insideValues FALSE) |
|||
elseif(NOT ${singleArgIndex} EQUAL -1) |
|||
set(currentArgName ${currentArg}) |
|||
set(${prefix}_${currentArgName}) |
|||
set(insideValues "SINGLE") |
|||
elseif(NOT ${multiArgIndex} EQUAL -1) |
|||
set(currentArgName ${currentArg}) |
|||
set(${prefix}_${currentArgName}) |
|||
set(insideValues "MULTI") |
|||
endif() |
|||
endif() |
|||
|
|||
endforeach() |
|||
|
|||
# propagate the result variables to the caller: |
|||
foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames}) |
|||
set(${prefix}_${arg_name} ${${prefix}_${arg_name}} PARENT_SCOPE) |
|||
endforeach() |
|||
set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE) |
|||
|
|||
endfunction() |
|||
@ -0,0 +1,33 @@ |
|||
# Find libcpuid |
|||
# |
|||
# Find the libcpuid includes and library |
|||
# |
|||
# if you nee to add a custom library search path, do it via via CMAKE_PREFIX_PATH |
|||
# |
|||
# This module defines |
|||
# CPUID_INCLUDE_DIRS, where to find header, etc. |
|||
# CPUID_LIBRARIES, the libraries needed to use cpuid. |
|||
# CPUID_FOUND, If false, do not try to use cpuid. |
|||
|
|||
# only look in default directories |
|||
find_path( |
|||
CPUID_INCLUDE_DIR |
|||
NAMES libcpuid/libcpuid.h |
|||
DOC "libcpuid include dir" |
|||
) |
|||
|
|||
find_library( |
|||
CPUID_LIBRARY |
|||
NAMES cpuid |
|||
DOC "libcpuid library" |
|||
) |
|||
|
|||
set(CPUID_INCLUDE_DIRS ${CPUID_INCLUDE_DIR}) |
|||
set(CPUID_LIBRARIES ${CPUID_LIBRARY}) |
|||
|
|||
# handle the QUIETLY and REQUIRED arguments and set CPUID_FOUND to TRUE |
|||
# if all listed variables are TRUE, hide their existence from configuration view |
|||
include(FindPackageHandleStandardArgs) |
|||
find_package_handle_standard_args(cpuid DEFAULT_MSG CPUID_INCLUDE_DIR CPUID_LIBRARY) |
|||
mark_as_advanced (CPUID_INCLUDE_DIR CPUID_LIBRARY) |
|||
|
|||
@ -0,0 +1,136 @@ |
|||
#.rst: |
|||
# FindOpenCL |
|||
# ---------- |
|||
# |
|||
# Try to find OpenCL |
|||
# |
|||
# Once done this will define:: |
|||
# |
|||
# OpenCL_FOUND - True if OpenCL was found |
|||
# OpenCL_INCLUDE_DIRS - include directories for OpenCL |
|||
# OpenCL_LIBRARIES - link against this library to use OpenCL |
|||
# OpenCL_VERSION_STRING - Highest supported OpenCL version (eg. 1.2) |
|||
# OpenCL_VERSION_MAJOR - The major version of the OpenCL implementation |
|||
# OpenCL_VERSION_MINOR - The minor version of the OpenCL implementation |
|||
# |
|||
# The module will also define two cache variables:: |
|||
# |
|||
# OpenCL_INCLUDE_DIR - the OpenCL include directory |
|||
# OpenCL_LIBRARY - the path to the OpenCL library |
|||
# |
|||
|
|||
#============================================================================= |
|||
# Copyright 2014 Matthaeus G. Chajdas |
|||
# |
|||
# Distributed under the OSI-approved BSD License (the "License"); |
|||
# see accompanying file Copyright.txt for details. |
|||
# |
|||
# This software is distributed WITHOUT ANY WARRANTY; without even the |
|||
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|||
# See the License for more information. |
|||
#============================================================================= |
|||
# (To distribute this file outside of CMake, substitute the full |
|||
# License text for the above reference.) |
|||
|
|||
function(_FIND_OPENCL_VERSION) |
|||
include(CheckSymbolExists) |
|||
include(CMakePushCheckState) |
|||
set(CMAKE_REQUIRED_QUIET ${OpenCL_FIND_QUIETLY}) |
|||
|
|||
CMAKE_PUSH_CHECK_STATE() |
|||
foreach(VERSION "2_0" "1_2" "1_1" "1_0") |
|||
set(CMAKE_REQUIRED_INCLUDES "${OpenCL_INCLUDE_DIR}") |
|||
|
|||
if(APPLE) |
|||
CHECK_SYMBOL_EXISTS( |
|||
CL_VERSION_${VERSION} |
|||
"${OpenCL_INCLUDE_DIR}/OpenCL/cl.h" |
|||
OPENCL_VERSION_${VERSION}) |
|||
else() |
|||
CHECK_SYMBOL_EXISTS( |
|||
CL_VERSION_${VERSION} |
|||
"${OpenCL_INCLUDE_DIR}/CL/cl.h" |
|||
OPENCL_VERSION_${VERSION}) |
|||
endif() |
|||
|
|||
if(OPENCL_VERSION_${VERSION}) |
|||
string(REPLACE "_" "." VERSION "${VERSION}") |
|||
set(OpenCL_VERSION_STRING ${VERSION} PARENT_SCOPE) |
|||
string(REGEX MATCHALL "[0-9]+" version_components "${VERSION}") |
|||
list(GET version_components 0 major_version) |
|||
list(GET version_components 1 minor_version) |
|||
set(OpenCL_VERSION_MAJOR ${major_version} PARENT_SCOPE) |
|||
set(OpenCL_VERSION_MINOR ${minor_version} PARENT_SCOPE) |
|||
break() |
|||
endif() |
|||
endforeach() |
|||
CMAKE_POP_CHECK_STATE() |
|||
endfunction() |
|||
|
|||
find_path(OpenCL_INCLUDE_DIR |
|||
NAMES |
|||
CL/cl.h OpenCL/cl.h |
|||
PATHS |
|||
ENV "PROGRAMFILES(X86)" |
|||
ENV AMDAPPSDKROOT |
|||
ENV INTELOCLSDKROOT |
|||
ENV NVSDKCOMPUTE_ROOT |
|||
ENV CUDA_PATH |
|||
ENV ATISTREAMSDKROOT |
|||
PATH_SUFFIXES |
|||
include |
|||
OpenCL/common/inc |
|||
"AMD APP/include") |
|||
|
|||
_FIND_OPENCL_VERSION() |
|||
|
|||
if(WIN32) |
|||
if(CMAKE_SIZEOF_VOID_P EQUAL 4) |
|||
find_library(OpenCL_LIBRARY |
|||
NAMES OpenCL |
|||
PATHS |
|||
ENV "PROGRAMFILES(X86)" |
|||
ENV AMDAPPSDKROOT |
|||
ENV INTELOCLSDKROOT |
|||
ENV CUDA_PATH |
|||
ENV NVSDKCOMPUTE_ROOT |
|||
ENV ATISTREAMSDKROOT |
|||
PATH_SUFFIXES |
|||
"AMD APP/lib/x86" |
|||
lib/x86 |
|||
lib/Win32 |
|||
OpenCL/common/lib/Win32) |
|||
elseif(CMAKE_SIZEOF_VOID_P EQUAL 8) |
|||
find_library(OpenCL_LIBRARY |
|||
NAMES OpenCL |
|||
PATHS |
|||
ENV "PROGRAMFILES(X86)" |
|||
ENV AMDAPPSDKROOT |
|||
ENV INTELOCLSDKROOT |
|||
ENV CUDA_PATH |
|||
ENV NVSDKCOMPUTE_ROOT |
|||
ENV ATISTREAMSDKROOT |
|||
PATH_SUFFIXES |
|||
"AMD APP/lib/x86_64" |
|||
lib/x86_64 |
|||
lib/x64 |
|||
OpenCL/common/lib/x64) |
|||
endif() |
|||
else() |
|||
find_library(OpenCL_LIBRARY |
|||
NAMES OpenCL) |
|||
endif() |
|||
|
|||
set(OpenCL_LIBRARIES ${OpenCL_LIBRARY}) |
|||
set(OpenCL_INCLUDE_DIRS ${OpenCL_INCLUDE_DIR}) |
|||
|
|||
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) |
|||
find_package_handle_standard_args( |
|||
OpenCL |
|||
FOUND_VAR OpenCL_FOUND |
|||
REQUIRED_VARS OpenCL_LIBRARY OpenCL_INCLUDE_DIR |
|||
VERSION_VAR OpenCL_VERSION_STRING) |
|||
|
|||
mark_as_advanced( |
|||
OpenCL_INCLUDE_DIR |
|||
OpenCL_LIBRARY) |
|||
@ -0,0 +1,382 @@ |
|||
#.rst: |
|||
# FindPackageHandleStandardArgs |
|||
# ----------------------------- |
|||
# |
|||
# |
|||
# |
|||
# FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> ... ) |
|||
# |
|||
# This function is intended to be used in FindXXX.cmake modules files. |
|||
# It handles the REQUIRED, QUIET and version-related arguments to |
|||
# find_package(). It also sets the <packagename>_FOUND variable. The |
|||
# package is considered found if all variables <var1>... listed contain |
|||
# valid results, e.g. valid filepaths. |
|||
# |
|||
# There are two modes of this function. The first argument in both |
|||
# modes is the name of the Find-module where it is called (in original |
|||
# casing). |
|||
# |
|||
# The first simple mode looks like this: |
|||
# |
|||
# :: |
|||
# |
|||
# FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> |
|||
# (DEFAULT_MSG|"Custom failure message") <var1>...<varN> ) |
|||
# |
|||
# If the variables <var1> to <varN> are all valid, then |
|||
# <UPPERCASED_NAME>_FOUND will be set to TRUE. If DEFAULT_MSG is given |
|||
# as second argument, then the function will generate itself useful |
|||
# success and error messages. You can also supply a custom error |
|||
# message for the failure case. This is not recommended. |
|||
# |
|||
# The second mode is more powerful and also supports version checking: |
|||
# |
|||
# :: |
|||
# |
|||
# FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME |
|||
# [FOUND_VAR <resultVar>] |
|||
# [REQUIRED_VARS <var1>...<varN>] |
|||
# [VERSION_VAR <versionvar>] |
|||
# [HANDLE_COMPONENTS] |
|||
# [CONFIG_MODE] |
|||
# [FAIL_MESSAGE "Custom failure message"] ) |
|||
# |
|||
# In this mode, the name of the result-variable can be set either to |
|||
# either <UPPERCASED_NAME>_FOUND or <OriginalCase_Name>_FOUND using the |
|||
# FOUND_VAR option. Other names for the result-variable are not |
|||
# allowed. So for a Find-module named FindFooBar.cmake, the two |
|||
# possible names are FooBar_FOUND and FOOBAR_FOUND. It is recommended |
|||
# to use the original case version. If the FOUND_VAR option is not |
|||
# used, the default is <UPPERCASED_NAME>_FOUND. |
|||
# |
|||
# As in the simple mode, if <var1> through <varN> are all valid, |
|||
# <packagename>_FOUND will be set to TRUE. After REQUIRED_VARS the |
|||
# variables which are required for this package are listed. Following |
|||
# VERSION_VAR the name of the variable can be specified which holds the |
|||
# version of the package which has been found. If this is done, this |
|||
# version will be checked against the (potentially) specified required |
|||
# version used in the find_package() call. The EXACT keyword is also |
|||
# handled. The default messages include information about the required |
|||
# version and the version which has been actually found, both if the |
|||
# version is ok or not. If the package supports components, use the |
|||
# HANDLE_COMPONENTS option to enable handling them. In this case, |
|||
# find_package_handle_standard_args() will report which components have |
|||
# been found and which are missing, and the <packagename>_FOUND variable |
|||
# will be set to FALSE if any of the required components (i.e. not the |
|||
# ones listed after OPTIONAL_COMPONENTS) are missing. Use the option |
|||
# CONFIG_MODE if your FindXXX.cmake module is a wrapper for a |
|||
# find_package(... NO_MODULE) call. In this case VERSION_VAR will be |
|||
# set to <NAME>_VERSION and the macro will automatically check whether |
|||
# the Config module was found. Via FAIL_MESSAGE a custom failure |
|||
# message can be specified, if this is not used, the default message |
|||
# will be displayed. |
|||
# |
|||
# Example for mode 1: |
|||
# |
|||
# :: |
|||
# |
|||
# find_package_handle_standard_args(LibXml2 DEFAULT_MSG |
|||
# LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR) |
|||
# |
|||
# |
|||
# |
|||
# LibXml2 is considered to be found, if both LIBXML2_LIBRARY and |
|||
# LIBXML2_INCLUDE_DIR are valid. Then also LIBXML2_FOUND is set to |
|||
# TRUE. If it is not found and REQUIRED was used, it fails with |
|||
# FATAL_ERROR, independent whether QUIET was used or not. If it is |
|||
# found, success will be reported, including the content of <var1>. On |
|||
# repeated Cmake runs, the same message won't be printed again. |
|||
# |
|||
# Example for mode 2: |
|||
# |
|||
# :: |
|||
# |
|||
# find_package_handle_standard_args(LibXslt |
|||
# FOUND_VAR LibXslt_FOUND |
|||
# REQUIRED_VARS LibXslt_LIBRARIES LibXslt_INCLUDE_DIRS |
|||
# VERSION_VAR LibXslt_VERSION_STRING) |
|||
# |
|||
# In this case, LibXslt is considered to be found if the variable(s) |
|||
# listed after REQUIRED_VAR are all valid, i.e. LibXslt_LIBRARIES and |
|||
# LibXslt_INCLUDE_DIRS in this case. The result will then be stored in |
|||
# LibXslt_FOUND . Also the version of LibXslt will be checked by using |
|||
# the version contained in LibXslt_VERSION_STRING. Since no |
|||
# FAIL_MESSAGE is given, the default messages will be printed. |
|||
# |
|||
# Another example for mode 2: |
|||
# |
|||
# :: |
|||
# |
|||
# find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4) |
|||
# find_package_handle_standard_args(Automoc4 CONFIG_MODE) |
|||
# |
|||
# In this case, FindAutmoc4.cmake wraps a call to find_package(Automoc4 |
|||
# NO_MODULE) and adds an additional search directory for automoc4. Here |
|||
# the result will be stored in AUTOMOC4_FOUND. The following |
|||
# FIND_PACKAGE_HANDLE_STANDARD_ARGS() call produces a proper |
|||
# success/error message. |
|||
|
|||
#============================================================================= |
|||
# Copyright 2007-2009 Kitware, Inc. |
|||
# |
|||
# Distributed under the OSI-approved BSD License (the "License"); |
|||
# see accompanying file Copyright.txt for details. |
|||
# |
|||
# This software is distributed WITHOUT ANY WARRANTY; without even the |
|||
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|||
# See the License for more information. |
|||
#============================================================================= |
|||
# (To distribute this file outside of CMake, substitute the full |
|||
# License text for the above reference.) |
|||
|
|||
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake) |
|||
include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseArguments.cmake) |
|||
|
|||
# internal helper macro |
|||
macro(_FPHSA_FAILURE_MESSAGE _msg) |
|||
if (${_NAME}_FIND_REQUIRED) |
|||
message(FATAL_ERROR "${_msg}") |
|||
else () |
|||
if (NOT ${_NAME}_FIND_QUIETLY) |
|||
message(STATUS "${_msg}") |
|||
endif () |
|||
endif () |
|||
endmacro() |
|||
|
|||
|
|||
# internal helper macro to generate the failure message when used in CONFIG_MODE: |
|||
macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE) |
|||
# <name>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found: |
|||
if(${_NAME}_CONFIG) |
|||
_FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing: ${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})") |
|||
else() |
|||
# If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version. |
|||
# List them all in the error message: |
|||
if(${_NAME}_CONSIDERED_CONFIGS) |
|||
set(configsText "") |
|||
list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount) |
|||
math(EXPR configsCount "${configsCount} - 1") |
|||
foreach(currentConfigIndex RANGE ${configsCount}) |
|||
list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename) |
|||
list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version) |
|||
set(configsText "${configsText} ${filename} (version ${version})\n") |
|||
endforeach() |
|||
if (${_NAME}_NOT_FOUND_MESSAGE) |
|||
set(configsText "${configsText} Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n") |
|||
endif() |
|||
_FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}") |
|||
|
|||
else() |
|||
# Simple case: No Config-file was found at all: |
|||
_FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}") |
|||
endif() |
|||
endif() |
|||
endmacro() |
|||
|
|||
|
|||
function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG) |
|||
|
|||
# set up the arguments for CMAKE_PARSE_ARGUMENTS and check whether we are in |
|||
# new extended or in the "old" mode: |
|||
set(options CONFIG_MODE HANDLE_COMPONENTS) |
|||
set(oneValueArgs FAIL_MESSAGE VERSION_VAR FOUND_VAR) |
|||
set(multiValueArgs REQUIRED_VARS) |
|||
set(_KEYWORDS_FOR_EXTENDED_MODE ${options} ${oneValueArgs} ${multiValueArgs} ) |
|||
list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX) |
|||
|
|||
if(${INDEX} EQUAL -1) |
|||
set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG}) |
|||
set(FPHSA_REQUIRED_VARS ${ARGN}) |
|||
set(FPHSA_VERSION_VAR) |
|||
else() |
|||
|
|||
CMAKE_PARSE_ARGUMENTS(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}" ${_FIRST_ARG} ${ARGN}) |
|||
|
|||
if(FPHSA_UNPARSED_ARGUMENTS) |
|||
message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"") |
|||
endif() |
|||
|
|||
if(NOT FPHSA_FAIL_MESSAGE) |
|||
set(FPHSA_FAIL_MESSAGE "DEFAULT_MSG") |
|||
endif() |
|||
endif() |
|||
|
|||
# now that we collected all arguments, process them |
|||
|
|||
if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG") |
|||
set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}") |
|||
endif() |
|||
|
|||
# In config-mode, we rely on the variable <package>_CONFIG, which is set by find_package() |
|||
# when it successfully found the config-file, including version checking: |
|||
if(FPHSA_CONFIG_MODE) |
|||
list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG) |
|||
list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS) |
|||
set(FPHSA_VERSION_VAR ${_NAME}_VERSION) |
|||
endif() |
|||
|
|||
if(NOT FPHSA_REQUIRED_VARS) |
|||
message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()") |
|||
endif() |
|||
|
|||
list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR) |
|||
|
|||
string(TOUPPER ${_NAME} _NAME_UPPER) |
|||
string(TOLOWER ${_NAME} _NAME_LOWER) |
|||
|
|||
if(FPHSA_FOUND_VAR) |
|||
if(FPHSA_FOUND_VAR MATCHES "^${_NAME}_FOUND$" OR FPHSA_FOUND_VAR MATCHES "^${_NAME_UPPER}_FOUND$") |
|||
set(_FOUND_VAR ${FPHSA_FOUND_VAR}) |
|||
else() |
|||
message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_NAME}_FOUND\" and \"${_NAME_UPPER}_FOUND\" are valid names.") |
|||
endif() |
|||
else() |
|||
set(_FOUND_VAR ${_NAME_UPPER}_FOUND) |
|||
endif() |
|||
|
|||
# collect all variables which were not found, so they can be printed, so the |
|||
# user knows better what went wrong (#6375) |
|||
set(MISSING_VARS "") |
|||
set(DETAILS "") |
|||
# check if all passed variables are valid |
|||
unset(${_FOUND_VAR}) |
|||
foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS}) |
|||
if(NOT ${_CURRENT_VAR}) |
|||
set(${_FOUND_VAR} FALSE) |
|||
set(MISSING_VARS "${MISSING_VARS} ${_CURRENT_VAR}") |
|||
else() |
|||
set(DETAILS "${DETAILS}[${${_CURRENT_VAR}}]") |
|||
endif() |
|||
endforeach() |
|||
if(NOT "${${_FOUND_VAR}}" STREQUAL "FALSE") |
|||
set(${_FOUND_VAR} TRUE) |
|||
endif() |
|||
|
|||
# component handling |
|||
unset(FOUND_COMPONENTS_MSG) |
|||
unset(MISSING_COMPONENTS_MSG) |
|||
|
|||
if(FPHSA_HANDLE_COMPONENTS) |
|||
foreach(comp ${${_NAME}_FIND_COMPONENTS}) |
|||
if(${_NAME}_${comp}_FOUND) |
|||
|
|||
if(NOT DEFINED FOUND_COMPONENTS_MSG) |
|||
set(FOUND_COMPONENTS_MSG "found components: ") |
|||
endif() |
|||
set(FOUND_COMPONENTS_MSG "${FOUND_COMPONENTS_MSG} ${comp}") |
|||
|
|||
else() |
|||
|
|||
if(NOT DEFINED MISSING_COMPONENTS_MSG) |
|||
set(MISSING_COMPONENTS_MSG "missing components: ") |
|||
endif() |
|||
set(MISSING_COMPONENTS_MSG "${MISSING_COMPONENTS_MSG} ${comp}") |
|||
|
|||
if(${_NAME}_FIND_REQUIRED_${comp}) |
|||
set(${_FOUND_VAR} FALSE) |
|||
set(MISSING_VARS "${MISSING_VARS} ${comp}") |
|||
endif() |
|||
|
|||
endif() |
|||
endforeach() |
|||
set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}") |
|||
set(DETAILS "${DETAILS}[c${COMPONENT_MSG}]") |
|||
endif() |
|||
|
|||
# version handling: |
|||
set(VERSION_MSG "") |
|||
set(VERSION_OK TRUE) |
|||
set(VERSION ${${FPHSA_VERSION_VAR}}) |
|||
|
|||
# check with DEFINED here as the requested or found version may be "0" |
|||
if (DEFINED ${_NAME}_FIND_VERSION) |
|||
if(DEFINED ${FPHSA_VERSION_VAR}) |
|||
|
|||
if(${_NAME}_FIND_VERSION_EXACT) # exact version required |
|||
# count the dots in the version string |
|||
string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${VERSION}") |
|||
# add one dot because there is one dot more than there are components |
|||
string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS) |
|||
if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT) |
|||
# Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT |
|||
# is at most 4 here. Therefore a simple lookup table is used. |
|||
if (${_NAME}_FIND_VERSION_COUNT EQUAL 1) |
|||
set(_VERSION_REGEX "[^.]*") |
|||
elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2) |
|||
set(_VERSION_REGEX "[^.]*\\.[^.]*") |
|||
elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3) |
|||
set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*") |
|||
else () |
|||
set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*") |
|||
endif () |
|||
string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${VERSION}") |
|||
unset(_VERSION_REGEX) |
|||
if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD) |
|||
set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"") |
|||
set(VERSION_OK FALSE) |
|||
else () |
|||
set(VERSION_MSG "(found suitable exact version \"${VERSION}\")") |
|||
endif () |
|||
unset(_VERSION_HEAD) |
|||
else () |
|||
if (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}") |
|||
set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"") |
|||
set(VERSION_OK FALSE) |
|||
else () |
|||
set(VERSION_MSG "(found suitable exact version \"${VERSION}\")") |
|||
endif () |
|||
endif () |
|||
unset(_VERSION_DOTS) |
|||
|
|||
else() # minimum version specified: |
|||
if ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}") |
|||
set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"") |
|||
set(VERSION_OK FALSE) |
|||
else () |
|||
set(VERSION_MSG "(found suitable version \"${VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")") |
|||
endif () |
|||
endif() |
|||
|
|||
else() |
|||
|
|||
# if the package was not found, but a version was given, add that to the output: |
|||
if(${_NAME}_FIND_VERSION_EXACT) |
|||
set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")") |
|||
else() |
|||
set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")") |
|||
endif() |
|||
|
|||
endif() |
|||
else () |
|||
if(VERSION) |
|||
set(VERSION_MSG "(found version \"${VERSION}\")") |
|||
endif() |
|||
endif () |
|||
|
|||
if(VERSION_OK) |
|||
set(DETAILS "${DETAILS}[v${VERSION}(${${_NAME}_FIND_VERSION})]") |
|||
else() |
|||
set(${_FOUND_VAR} FALSE) |
|||
endif() |
|||
|
|||
|
|||
# print the result: |
|||
if (${_FOUND_VAR}) |
|||
FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}") |
|||
else () |
|||
|
|||
if(FPHSA_CONFIG_MODE) |
|||
_FPHSA_HANDLE_FAILURE_CONFIG_MODE() |
|||
else() |
|||
if(NOT VERSION_OK) |
|||
_FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})") |
|||
else() |
|||
_FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing: ${MISSING_VARS}) ${VERSION_MSG}") |
|||
endif() |
|||
endif() |
|||
|
|||
endif () |
|||
|
|||
set(${_FOUND_VAR} ${${_FOUND_VAR}} PARENT_SCOPE) |
|||
|
|||
endfunction() |
|||
@ -0,0 +1,57 @@ |
|||
#.rst: |
|||
# FindPackageMessage |
|||
# ------------------ |
|||
# |
|||
# |
|||
# |
|||
# FIND_PACKAGE_MESSAGE(<name> "message for user" "find result details") |
|||
# |
|||
# This macro is intended to be used in FindXXX.cmake modules files. It |
|||
# will print a message once for each unique find result. This is useful |
|||
# for telling the user where a package was found. The first argument |
|||
# specifies the name (XXX) of the package. The second argument |
|||
# specifies the message to display. The third argument lists details |
|||
# about the find result so that if they change the message will be |
|||
# displayed again. The macro also obeys the QUIET argument to the |
|||
# find_package command. |
|||
# |
|||
# Example: |
|||
# |
|||
# :: |
|||
# |
|||
# if(X11_FOUND) |
|||
# FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}" |
|||
# "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]") |
|||
# else() |
|||
# ... |
|||
# endif() |
|||
|
|||
#============================================================================= |
|||
# Copyright 2008-2009 Kitware, Inc. |
|||
# |
|||
# Distributed under the OSI-approved BSD License (the "License"); |
|||
# see accompanying file Copyright.txt for details. |
|||
# |
|||
# This software is distributed WITHOUT ANY WARRANTY; without even the |
|||
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|||
# See the License for more information. |
|||
#============================================================================= |
|||
# (To distribute this file outside of CMake, substitute the full |
|||
# License text for the above reference.) |
|||
|
|||
function(FIND_PACKAGE_MESSAGE pkg msg details) |
|||
# Avoid printing a message repeatedly for the same find result. |
|||
if(NOT ${pkg}_FIND_QUIETLY) |
|||
string(REPLACE "\n" "" details "${details}") |
|||
set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg}) |
|||
if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}") |
|||
# The message has not yet been printed. |
|||
message(STATUS "${msg}") |
|||
|
|||
# Save the find details in the cache to avoid printing the same |
|||
# message again. |
|||
set("${DETAILS_VAR}" "${details}" |
|||
CACHE INTERNAL "Details about finding ${pkg}") |
|||
endif() |
|||
endif() |
|||
endfunction() |
|||
@ -0,0 +1,18 @@ |
|||
# this module expects |
|||
# DLLS |
|||
# CONF |
|||
# DESTINATION |
|||
|
|||
# example usage: |
|||
# cmake -DDLL_DEBUG=xd.dll -DDLL_RELEASE=x.dll -DCONFIGURATION=Release -DDESTINATION=dest -P scripts/copydlls.cmake |
|||
|
|||
# this script is created cause we do not know configuration in multiconfiguration generators at cmake configure phase ;) |
|||
|
|||
if ("${CONF}" STREQUAL "Release") |
|||
set(DLL ${DLL_RELEASE}) |
|||
else () # Debug |
|||
set(DLL ${DLL_DEBUG}) |
|||
endif() |
|||
|
|||
execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${DLL}" "${DESTINATION}") |
|||
|
|||
@ -0,0 +1,38 @@ |
|||
/**
|
|||
* This file is generated by jsonrpcstub, DO NOT CHANGE IT MANUALLY! |
|||
*/ |
|||
|
|||
#ifndef JSONRPC_CPP_STUB_FARM_H_ |
|||
#define JSONRPC_CPP_STUB_FARM_H_ |
|||
|
|||
#include <jsonrpccpp/client.h> |
|||
|
|||
class Farm : public jsonrpc::Client |
|||
{ |
|||
public: |
|||
Farm(jsonrpc::IClientConnector &conn, jsonrpc::clientVersion_t type = jsonrpc::JSONRPC_CLIENT_V2) : jsonrpc::Client(conn, type) {} |
|||
|
|||
Json::Value eth_getWork() throw (jsonrpc::JsonRpcException) |
|||
{ |
|||
Json::Value p; |
|||
p = Json::nullValue; |
|||
Json::Value result = this->CallMethod("eth_getWork",p); |
|||
if (result.isArray()) |
|||
return result; |
|||
else |
|||
throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString()); |
|||
} |
|||
bool eth_submitWork(const std::string& param1, const std::string& param2) throw (jsonrpc::JsonRpcException) |
|||
{ |
|||
Json::Value p; |
|||
p.append(param1); |
|||
p.append(param2); |
|||
Json::Value result = this->CallMethod("eth_submitWork",p); |
|||
if (result.isBool()) |
|||
return result.asBool(); |
|||
else |
|||
throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString()); |
|||
} |
|||
}; |
|||
|
|||
#endif //JSONRPC_CPP_STUB_FARM_H_
|
|||
@ -0,0 +1,28 @@ |
|||
/**
|
|||
* This file is generated by jsonrpcstub, DO NOT CHANGE IT MANUALLY! |
|||
*/ |
|||
|
|||
#ifndef JSONRPC_CPP_STUB_PHONEHOME_H_ |
|||
#define JSONRPC_CPP_STUB_PHONEHOME_H_ |
|||
|
|||
#include <jsonrpccpp/client.h> |
|||
|
|||
class PhoneHome : public jsonrpc::Client |
|||
{ |
|||
public: |
|||
PhoneHome(jsonrpc::IClientConnector &conn, jsonrpc::clientVersion_t type = jsonrpc::JSONRPC_CLIENT_V2) : jsonrpc::Client(conn, type) {} |
|||
|
|||
int report_benchmark(const std::string& param1, int param2) throw (jsonrpc::JsonRpcException) |
|||
{ |
|||
Json::Value p; |
|||
p.append(param1); |
|||
p.append(param2); |
|||
Json::Value result = this->CallMethod("report_benchmark",p); |
|||
if (result.isInt()) |
|||
return result.asInt(); |
|||
else |
|||
throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString()); |
|||
} |
|||
}; |
|||
|
|||
#endif //JSONRPC_CPP_STUB_PHONEHOME_H_
|
|||
@ -0,0 +1,4 @@ |
|||
[ |
|||
{ "name": "eth_getWork", "params": [], "order": [], "returns": []}, |
|||
{ "name": "eth_submitWork", "params": ["", ""], "order": [], "returns": true} |
|||
] |
|||
@ -0,0 +1,3 @@ |
|||
[ |
|||
{ "name": "report_benchmark", "params": [ "", 0 ], "order": [], "returns": 0 } |
|||
] |
|||
@ -0,0 +1,32 @@ |
|||
REM get stuff! |
|||
if not exist download mkdir download |
|||
if not exist install mkdir install |
|||
if not exist install\windows mkdir install\windows |
|||
|
|||
set eth_server=https://build.ethdev.com/builds/windows-precompiled |
|||
|
|||
call :download boost 1.55.0 |
|||
call :download cryptopp 5.6.2 |
|||
call :download curl 7.4.2 |
|||
call :download jsoncpp 1.6.2 |
|||
call :download json-rpc-cpp 0.5.0 |
|||
call :download leveldb 1.2 |
|||
call :download microhttpd 0.9.2 |
|||
call :download qt 5.4.1 |
|||
|
|||
goto :EOF |
|||
|
|||
:download |
|||
|
|||
set eth_name=%1 |
|||
set eth_version=%2 |
|||
|
|||
cd download |
|||
|
|||
if not exist %eth_name%-%eth_version%.tar.gz curl -o %eth_name%-%eth_version%.tar.gz %eth_server%/%eth_name%-%eth_version%.tar.gz |
|||
if not exist %eth_name%-%eth_version% tar -zxvf %eth_name%-%eth_version%.tar.gz |
|||
cmake -E copy_directory %eth_name%-%eth_version% ..\install\windows |
|||
|
|||
cd ..\download |
|||
|
|||
goto :EOF |
|||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -1,14 +1,13 @@ |
|||
// dont override global variable
|
|||
if (typeof web3 !== 'undefined') { |
|||
var web3; |
|||
} |
|||
|
|||
web3 = require('./lib/web3'); |
|||
var web3 = require('./lib/web3'); |
|||
web3.providers.HttpProvider = require('./lib/web3/httpprovider'); |
|||
web3.providers.QtSyncProvider = require('./lib/web3/qtsync'); |
|||
web3.eth.contract = require('./lib/web3/contract'); |
|||
web3.abi = require('./lib/solidity/abi'); |
|||
|
|||
|
|||
// dont override global variable
|
|||
if (typeof window !== 'undefined' && typeof window.web3 === 'undefined') { |
|||
window.web3 = web3; |
|||
} |
|||
|
|||
module.exports = web3; |
|||
|
|||
|
|||
@ -0,0 +1,68 @@ |
|||
/* |
|||
This file is part of ethereum.js. |
|||
|
|||
ethereum.js is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU Lesser General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
ethereum.js 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 Lesser General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU Lesser General Public License |
|||
along with ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** |
|||
* @file utils.js |
|||
* @author Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
/** |
|||
* Returns the contstructor with matching number of arguments |
|||
* |
|||
* @method getConstructor |
|||
* @param {Array} abi |
|||
* @param {Number} numberOfArgs |
|||
* @returns {Object} constructor function abi |
|||
*/ |
|||
var getConstructor = function (abi, numberOfArgs) { |
|||
return abi.filter(function (f) { |
|||
return f.type === 'constructor' && f.inputs.length === numberOfArgs; |
|||
})[0]; |
|||
}; |
|||
|
|||
/** |
|||
* Filters all functions from input abi |
|||
* |
|||
* @method filterFunctions |
|||
* @param {Array} abi |
|||
* @returns {Array} abi array with filtered objects of type 'function' |
|||
*/ |
|||
var filterFunctions = function (json) { |
|||
return json.filter(function (current) { |
|||
return current.type === 'function'; |
|||
}); |
|||
}; |
|||
|
|||
/** |
|||
* Filters all events from input abi |
|||
* |
|||
* @method filterEvents |
|||
* @param {Array} abi |
|||
* @returns {Array} abi array with filtered objects of type 'event' |
|||
*/ |
|||
var filterEvents = function (json) { |
|||
return json.filter(function (current) { |
|||
return current.type === 'event'; |
|||
}); |
|||
}; |
|||
|
|||
module.exports = { |
|||
getConstructor: getConstructor, |
|||
filterFunctions: filterFunctions, |
|||
filterEvents: filterEvents |
|||
}; |
|||
|
|||
@ -1,3 +1,3 @@ |
|||
{ |
|||
"version": "0.2.5" |
|||
"version": "0.2.6" |
|||
} |
|||
|
|||
@ -0,0 +1,106 @@ |
|||
var chai = require('chai'); |
|||
var assert = require('assert'); |
|||
var abi = require('../lib/solidity/abi'); |
|||
|
|||
describe('lib/solidity/abi', function () { |
|||
describe('formatConstructorParams', function () { |
|||
it('should format uint256 properly', function () { |
|||
// given
|
|||
var description = [{ |
|||
"name": "test", |
|||
"type": "constructor", |
|||
"inputs": [{ |
|||
"name": "a", |
|||
"type": "uint256" |
|||
} |
|||
] |
|||
}]; |
|||
|
|||
// when
|
|||
var bytes = abi.formatConstructorParams(description, [2]); |
|||
|
|||
// then
|
|||
assert.equal(bytes, '0000000000000000000000000000000000000000000000000000000000000002'); |
|||
}); |
|||
|
|||
it('should not find matching constructor', function () { |
|||
// given
|
|||
var description = [{ |
|||
"name": "test", |
|||
"type": "constructor", |
|||
"inputs": [{ |
|||
"name": "a", |
|||
"type": "uint256" |
|||
} |
|||
] |
|||
}]; |
|||
|
|||
// when
|
|||
var bytes = abi.formatConstructorParams(description, []); |
|||
|
|||
// then
|
|||
assert.equal(bytes, ''); |
|||
}); |
|||
|
|||
it('should not find matching constructor2', function () { |
|||
// given
|
|||
var description = [{ |
|||
"name": "test", |
|||
"type": "constructor", |
|||
"inputs": [{ |
|||
"name": "a", |
|||
"type": "uint256" |
|||
} |
|||
] |
|||
}]; |
|||
|
|||
// when
|
|||
var bytes = abi.formatConstructorParams(description, [1,2]); |
|||
|
|||
// then
|
|||
assert.equal(bytes, ''); |
|||
}); |
|||
|
|||
it('should not find matching constructor3', function () { |
|||
// given
|
|||
var description = [{ |
|||
"name": "test", |
|||
"type": "function", |
|||
"inputs": [{ |
|||
"name": "a", |
|||
"type": "uint256" |
|||
} |
|||
] |
|||
}]; |
|||
|
|||
// when
|
|||
var bytes = abi.formatConstructorParams(description, [2]); |
|||
|
|||
// then
|
|||
assert.equal(bytes, ''); |
|||
}); |
|||
|
|||
it('should find matching constructor with multiple args', function () { |
|||
// given
|
|||
var description = [{ |
|||
"name": "test", |
|||
"type": "constructor", |
|||
"inputs": [{ |
|||
"name": "a", |
|||
"type": "uint256" |
|||
}, { |
|||
"name": "b", |
|||
"type": "uint256" |
|||
}] |
|||
}]; |
|||
|
|||
// when
|
|||
var bytes = abi.formatConstructorParams(description, ['1', '5']); |
|||
|
|||
// then
|
|||
assert.equal(bytes, '00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000005'); |
|||
}); |
|||
}); |
|||
}); |
|||
|
|||
|
|||
@ -0,0 +1,23 @@ |
|||
var chai = require('chai'); |
|||
var utils = require('../lib/utils/utils.js'); |
|||
var assert = chai.assert; |
|||
|
|||
var tests = [ |
|||
{ value: function () {}, is: false}, |
|||
{ value: new Function(), is: false}, |
|||
{ value: 'function', is: false}, |
|||
{ value: {}, is: false}, |
|||
{ value: '0xc6d9d2cd449a754c494264e1809c50e34d64562b', is: true }, |
|||
{ value: 'c6d9d2cd449a754c494264e1809c50e34d64562b', is: false } |
|||
]; |
|||
|
|||
describe('lib/utils/utils', function () { |
|||
describe('isStrictAddress', function () { |
|||
tests.forEach(function (test) { |
|||
it('shoud test if value ' + test.value + ' is address: ' + test.is, function () { |
|||
assert.equal(utils.isStrictAddress(test.value), test.is); |
|||
}); |
|||
}); |
|||
}); |
|||
}); |
|||
|
|||
@ -0,0 +1,39 @@ |
|||
var chai = require('chai'); |
|||
var assert = chai.assert; |
|||
var web3 = require('../index'); |
|||
var BigNumber = require('bignumber.js'); |
|||
var FakeHttpProvider = require('./helpers/FakeHttpProvider'); |
|||
|
|||
var method = 'gasPrice'; |
|||
|
|||
var tests = [{ |
|||
result: '0x15f90', |
|||
formattedResult: new BigNumber(90000), |
|||
call: 'eth_'+ method |
|||
}]; |
|||
|
|||
describe('web3.eth', function () { |
|||
describe(method, function () { |
|||
tests.forEach(function (test, index) { |
|||
it('property test: ' + index, function () { |
|||
|
|||
// given
|
|||
var provider = new FakeHttpProvider(); |
|||
web3.setProvider(provider); |
|||
provider.injectResult(test.result); |
|||
provider.injectValidation(function (payload) { |
|||
assert.equal(payload.jsonrpc, '2.0'); |
|||
assert.equal(payload.method, test.call); |
|||
assert.deepEqual(payload.params, []); |
|||
}); |
|||
|
|||
// when
|
|||
var result = web3.eth[method]; |
|||
|
|||
// then
|
|||
assert.deepEqual(test.formattedResult, result); |
|||
}); |
|||
}); |
|||
}); |
|||
}); |
|||
|
|||
Loading…
Reference in new issue