diff options
119 files changed, 4571 insertions, 3714 deletions
diff --git a/HOWTO/INSTALL.md b/HOWTO/INSTALL.md index 43bcdb3a9e..adfc44baae 100644 --- a/HOWTO/INSTALL.md +++ b/HOWTO/INSTALL.md @@ -356,8 +356,6 @@ Some of the available `configure` options are: depending on operating system and hardware platform. Note that by enabling this you might get a seemingly working system that sometimes fail on floating point operations. -* `--enable-darwin-universal` - Build universal binaries on darwin i386. -* `--enable-darwin-64bit` - Build 64-bit binaries on darwin * `--enable-m64-build` - Build 64-bit binaries using the `-m64` flag to `(g)cc` * `--enable-m32-build` - Build 32-bit binaries using the `-m32` flag to diff --git a/bootstrap/bin/start.boot b/bootstrap/bin/start.boot Binary files differindex 73381d4d8b..e07137fd5c 100644 --- a/bootstrap/bin/start.boot +++ b/bootstrap/bin/start.boot diff --git a/bootstrap/bin/start_clean.boot b/bootstrap/bin/start_clean.boot Binary files differindex 73381d4d8b..e07137fd5c 100644 --- a/bootstrap/bin/start_clean.boot +++ b/bootstrap/bin/start_clean.boot diff --git a/bootstrap/lib/compiler/ebin/beam_asm.beam b/bootstrap/lib/compiler/ebin/beam_asm.beam Binary files differindex ae57c8dd6b..3249ce70a5 100644 --- a/bootstrap/lib/compiler/ebin/beam_asm.beam +++ b/bootstrap/lib/compiler/ebin/beam_asm.beam diff --git a/bootstrap/lib/compiler/ebin/compile.beam b/bootstrap/lib/compiler/ebin/compile.beam Binary files differindex 5234f98a75..a0c114bf7e 100644 --- a/bootstrap/lib/compiler/ebin/compile.beam +++ b/bootstrap/lib/compiler/ebin/compile.beam diff --git a/bootstrap/lib/compiler/ebin/compiler.app b/bootstrap/lib/compiler/ebin/compiler.app index 37a6ce4acb..c5ec501890 100644 --- a/bootstrap/lib/compiler/ebin/compiler.app +++ b/bootstrap/lib/compiler/ebin/compiler.app @@ -19,7 +19,7 @@ {application, compiler, [{description, "ERTS CXC 138 10"}, - {vsn, "6.0.2"}, + {vsn, "6.0.3"}, {modules, [ beam_a, beam_asm, diff --git a/bootstrap/lib/compiler/ebin/compiler.appup b/bootstrap/lib/compiler/ebin/compiler.appup index ceb96264d5..0cdf00818d 100644 --- a/bootstrap/lib/compiler/ebin/compiler.appup +++ b/bootstrap/lib/compiler/ebin/compiler.appup @@ -16,7 +16,7 @@ %% limitations under the License. %% %% %CopyrightEnd% -{"6.0.2", +{"6.0.3", [{<<".*">>,[{restart_application, compiler}]}], [{<<".*">>,[{restart_application, compiler}]}] }. diff --git a/bootstrap/lib/kernel/ebin/code_server.beam b/bootstrap/lib/kernel/ebin/code_server.beam Binary files differindex 135fd066d9..aa1ba78550 100644 --- a/bootstrap/lib/kernel/ebin/code_server.beam +++ b/bootstrap/lib/kernel/ebin/code_server.beam diff --git a/bootstrap/lib/kernel/ebin/erl_distribution.beam b/bootstrap/lib/kernel/ebin/erl_distribution.beam Binary files differindex eacacf799c..198f23e14b 100644 --- a/bootstrap/lib/kernel/ebin/erl_distribution.beam +++ b/bootstrap/lib/kernel/ebin/erl_distribution.beam diff --git a/bootstrap/lib/kernel/ebin/hipe_unified_loader.beam b/bootstrap/lib/kernel/ebin/hipe_unified_loader.beam Binary files differindex a90757bd32..b1b7fcdef2 100644 --- a/bootstrap/lib/kernel/ebin/hipe_unified_loader.beam +++ b/bootstrap/lib/kernel/ebin/hipe_unified_loader.beam diff --git a/bootstrap/lib/kernel/ebin/kernel.app b/bootstrap/lib/kernel/ebin/kernel.app index 14f526c30c..49163534f8 100644 --- a/bootstrap/lib/kernel/ebin/kernel.app +++ b/bootstrap/lib/kernel/ebin/kernel.app @@ -22,7 +22,7 @@ {application, kernel, [ {description, "ERTS CXC 138 10"}, - {vsn, "4.1.1"}, + {vsn, "4.2"}, {modules, [application, application_controller, application_master, @@ -116,6 +116,6 @@ {applications, []}, {env, [{error_logger, tty}]}, {mod, {kernel, []}}, - {runtime_dependencies, ["erts-7.3", "stdlib-2.6", "sasl-2.6"]} + {runtime_dependencies, ["erts-8.0", "stdlib-2.6", "sasl-2.6"]} ] }. diff --git a/bootstrap/lib/kernel/ebin/kernel.appup b/bootstrap/lib/kernel/ebin/kernel.appup index 5cd6724383..dbbc1ef977 100644 --- a/bootstrap/lib/kernel/ebin/kernel.appup +++ b/bootstrap/lib/kernel/ebin/kernel.appup @@ -16,11 +16,11 @@ %% limitations under the License. %% %% %CopyrightEnd% -{"4.1.1", +{"4.2", %% Up from - max one major revision back - [{<<"4\\.[0-1](\\.[0-9]+)*">>,[restart_new_emulator]}, % OTP-18.* - {<<"3\\.[0-2](\\.[0-9]+)*">>,[restart_new_emulator]}], % OTP-17 + [{<<"5\\.0(\\.[0-9]+)*">>,[restart_new_emulator]}, % OTP-19.* + {<<"4\\.[0-2](\\.[0-9]+)*">>,[restart_new_emulator]}], % OTP-18.* %% Down to - max one major revision back - [{<<"4\\.[0-1](\\.[0-9]+)*">>,[restart_new_emulator]}, % OTP-18.* - {<<"3\\.[0-2](\\.[0-9]+)*">>,[restart_new_emulator]}] % OTP-17 + [{<<"5\\.0(\\.[0-9]+)*">>,[restart_new_emulator]}, % OTP-19.* + {<<"4\\.[0-2](\\.[0-9]+)*">>,[restart_new_emulator]}] % OTP-18.* }. diff --git a/bootstrap/lib/kernel/ebin/net_kernel.beam b/bootstrap/lib/kernel/ebin/net_kernel.beam Binary files differindex bd15759017..8afe1c0388 100644 --- a/bootstrap/lib/kernel/ebin/net_kernel.beam +++ b/bootstrap/lib/kernel/ebin/net_kernel.beam diff --git a/bootstrap/lib/kernel/ebin/rpc.beam b/bootstrap/lib/kernel/ebin/rpc.beam Binary files differindex 4d1cbdb625..b7dc70231b 100644 --- a/bootstrap/lib/kernel/ebin/rpc.beam +++ b/bootstrap/lib/kernel/ebin/rpc.beam diff --git a/bootstrap/lib/stdlib/ebin/filename.beam b/bootstrap/lib/stdlib/ebin/filename.beam Binary files differindex 7f6818db30..95e4d69df0 100644 --- a/bootstrap/lib/stdlib/ebin/filename.beam +++ b/bootstrap/lib/stdlib/ebin/filename.beam diff --git a/bootstrap/lib/stdlib/ebin/stdlib.app b/bootstrap/lib/stdlib/ebin/stdlib.app index 7287cbd451..97910ada4f 100644 --- a/bootstrap/lib/stdlib/ebin/stdlib.app +++ b/bootstrap/lib/stdlib/ebin/stdlib.app @@ -20,7 +20,7 @@ %% {application, stdlib, [{description, "ERTS CXC 138 10"}, - {vsn, "2.7"}, + {vsn, "2.8"}, {modules, [array, base64, beam_lib, diff --git a/bootstrap/lib/stdlib/ebin/stdlib.appup b/bootstrap/lib/stdlib/ebin/stdlib.appup index 8b0206f6be..58af9ab142 100644 --- a/bootstrap/lib/stdlib/ebin/stdlib.appup +++ b/bootstrap/lib/stdlib/ebin/stdlib.appup @@ -16,11 +16,11 @@ %% limitations under the License. %% %% %CopyrightEnd% -{"2.7", +{"2.8", %% Up from - max one major revision back - [{<<"2\\.[5-7](\\.[0-9]+)*">>,[restart_new_emulator]}, % OTP-18.* - {<<"2\\.[0-4](\\.[0-9]+)*">>,[restart_new_emulator]}], % 17.0-17.5 + [{<<"3\\.0(\\.[0-9]+)*">>,[restart_new_emulator]}, % OTP-19.* + {<<"2\\.[5-8](\\.[0-9]+)*">>,[restart_new_emulator]}], % OTP-18.* %% Down to - max one major revision back - [{<<"2\\.[5-7](\\.[0-9]+)*">>,[restart_new_emulator]}, % OTP-18.* - {<<"2\\.[0-4](\\.[0-9]+)*">>,[restart_new_emulator]}] % 17.0-17.5 + [{<<"3\\.0(\\.[0-9]+)*">>,[restart_new_emulator]}, % OTP-19.* + {<<"2\\.[5-8](\\.[0-9]+)*">>,[restart_new_emulator]}] % OTP-18.* }. diff --git a/configure.in b/configure.in index 89486590b8..fc9aeee455 100644 --- a/configure.in +++ b/configure.in @@ -297,24 +297,6 @@ dnl *) erl_mandir='$(erlang_libdir)/man' ;; dnl esac ], erl_mandir='$(erlang_libdir)/man') dnl AC_SUBST(erl_mandir) -AC_ARG_ENABLE(darwin-universal, -AS_HELP_STRING([--enable-darwin-universal], - [build universal binaries on darwin i386]), -[ case "$enableval" in - no) enable_darwin_universal=no ;; - *) enable_darwin_univeral=yes ;; - esac -],enable_darwin_universal=no) - - -AC_ARG_ENABLE(darwin-64bit, -AS_HELP_STRING([--enable-darwin-64bit], [build 64bit binaries on darwin]), -[ case "$enableval" in - no) enable_darwin_64bit=no ;; - *) enable_darwin_64bit=yes ;; - esac -],enable_darwin_64bit=no) - AC_ARG_ENABLE(m64-build, AS_HELP_STRING([--enable-m64-build], [build 64bit binaries using the -m64 flag to (g)cc]), @@ -329,12 +311,7 @@ AS_HELP_STRING([--enable-m32-build], [build 32bit binaries using the -m32 flag to (g)cc]), [ case "$enableval" in no) enable_m32_build=no ;; - *) - if test X${enable_darwin_64bit} = Xyes -o X${enable_m64_build} = Xyes; - then - AC_MSG_ERROR([(--enable-darwin-64bit or --enable-m64-build) and --enable-m32-build are mutually exclusive]) ; - fi ; - enable_m32_build=yes ;; + *) enable_m32_build=yes ;; esac ],enable_m32_build=no) @@ -342,42 +319,6 @@ AC_ARG_WITH(libatomic_ops, AS_HELP_STRING([--with-libatomic_ops=PATH], [specify and prefer usage of libatomic_ops in the ethread library])) -dnl OK, we might have darwin switches off different kinds, lets -dnl check it all before continuing. -TMPSYS=`uname -s`-`uname -m` -if test X${enable_darwin_universal} = Xyes; then - if test X${enable_darwin_64bit} = Xyes; then - AC_MSG_ERROR([--enable-darwin-universal and --enable-darwin-64bit mutually exclusive]) - fi - enable_hipe=no - CFLAGS="-arch i386 -arch ppc $CFLAGS" - export CFLAGS - LDFLAGS="-arch i386 -arch ppc $LDFLAGS" - export LDFLAGS -fi -if test X${enable_darwin_64bit} = Xyes; then - case "$TMPSYS" in - Darwin-i386|Darwin-x86_64) - ;; - Darwin*) - AC_MSG_ERROR([--enable-darwin-64bit only supported on x86 hosts]) - ;; - *) - AC_MSG_ERROR([--enable-darwin-64bit only supported on Darwin]) - ;; - esac - enable_hipe=no - CFLAGS="-m64 $CFLAGS" - export CFLAGS - LDFLAGS="-m64 $LDFLAGS" - export LDFLAGS -elif test X"$TMPSYS" '=' X"Darwin-i386"; then - CFLAGS="-m32 $CFLAGS" - export CFLAGS - LDFLAGS="-m32 $LDFLAGS" - export LDFLAGS -fi - m4_define(DEFAULT_SANITIZERS, [address,undefined]) AC_ARG_ENABLE(sanitizers, AS_HELP_STRING( diff --git a/erts/configure.in b/erts/configure.in index 1d15ae467c..77a4d32787 100644 --- a/erts/configure.in +++ b/erts/configure.in @@ -215,24 +215,6 @@ AS_HELP_STRING([--enable-fp-exceptions], esac ],enable_fp_exceptions=auto) -AC_ARG_ENABLE(darwin-universal, -AS_HELP_STRING([--enable-darwin-universal], - [build universal binaries on darwin i386]), -[ case "$enableval" in - no) enable_darwin_universal=no ;; - *) enable_darwin_univeral=yes ;; - esac -],enable_darwin_universal=no) - - -AC_ARG_ENABLE(darwin-64bit, -AS_HELP_STRING([--enable-darwin-64bit], [build 64bit binaries on darwin]), -[ case "$enableval" in - no) enable_darwin_64bit=no ;; - *) enable_darwin_64bit=yes ;; - esac -],enable_darwin_64bit=no) - AC_ARG_ENABLE(m64-build, AS_HELP_STRING([--enable-m64-build], [build 64bit binaries using the -m64 flag to (g)cc]), @@ -247,12 +229,7 @@ AS_HELP_STRING([--enable-m32-build], [build 32bit binaries using the -m32 flag to (g)cc]), [ case "$enableval" in no) enable_m32_build=no ;; - *) - if test X${enable_darwin_64bit} = Xyes -o X${enable_m64_build} = Xyes; - then - AC_MSG_ERROR([(--enable-darwin-64bit or --enable-m64-build) and --enable-m32-build are mutually exclusive]) ; - fi ; - enable_m32_build=yes ;; + *) enable_m32_build=yes ;; esac ],enable_m32_build=no) @@ -377,42 +354,7 @@ AC_MSG_CHECKING([OTP version]) AC_MSG_RESULT([$OTP_VERSION]) AC_SUBST(OTP_VERSION) -dnl OK, we might have darwin switches off different kinds, lets -dnl check it all before continuing. -TMPSYS=`uname -s`-`uname -m` -if test X${enable_darwin_universal} = Xyes; then - if test X${enable_darwin_64bit} = Xyes; then - AC_MSG_ERROR([--enable-darwin-universal and --enable-darwin-64bit mutually exclusive]) - fi - enable_hipe=no - case $CFLAGS in - *-arch\ ppc*) - ;; - *) - CFLAGS="-arch ppc $CFLAGS" - ;; - esac - case $CFLAGS in - *-arch\ i386*) - ;; - *) - CFLAGS="-arch i386 $CFLAGS" - ;; - esac -fi -if test X${enable_darwin_64bit} = Xyes; then - case "$TMPSYS" in - Darwin-i386|Darwin-x86_64) - ;; - Darwin*) - AC_MSG_ERROR([--enable-darwin-64bit only supported on x86 hosts]) - ;; - *) - AC_MSG_ERROR([--enable-darwin-64bit only supported on Darwin]) - ;; - esac -fi -if test X${enable_darwin_64bit} = Xyes -o X${enable_m64_build} = Xyes; then +if test X${enable_m64_build} = Xyes; then case $CFLAGS in *-m64*) ;; @@ -735,32 +677,13 @@ case $ARCH-$OPSYS in esac ;; *-darwin*) - if test X${enable_darwin_universal} = Xyes; then - AC_MSG_NOTICE([Adjusting LDFLAGS for universal binaries]) - - case $LDFLAGS in - *-arch\ ppc*) - ;; - *) - LDFLAGS="-arch ppc $LDFLAGS" - ;; - esac - case $LDFLAGS in - *-arch\ i386*) - ;; - *) - LDFLAGS="-arch i386 $LDFLAGS" - ;; - esac - else - case $LDFLAGS in - *-m32*) - ;; - *) - LDFLAGS="-m32 $LDFLAGS" - ;; - esac - fi + case $LDFLAGS in + *-m32*) + ;; + *) + LDFLAGS="-m32 $LDFLAGS" + ;; + esac ;; *) if test X${enable_m64_build} = Xyes; then @@ -3747,14 +3670,8 @@ case $host_os in DED_LDFLAGS="-m64 $DED_LDFLAGS" ;; *) - if test X${enable_darwin_universal} != Xyes; then - DED_LDFLAGS="-m32 $DED_LDFLAGS" - fi ;; esac - if test X${enable_darwin_universal} = Xyes; then - DED_LDFLAGS="-arch ppc -arch i386 $DED_LDFLAGS" - fi DED_LD="$CC" DED_LD_FLAG_RUNTIME_LIBRARY_PATH="$CFLAG_RUNTIME_LIBRARY_PATH" ;; diff --git a/erts/doc/src/erl_nif.xml b/erts/doc/src/erl_nif.xml index be0e406b9c..1e95634d1b 100644 --- a/erts/doc/src/erl_nif.xml +++ b/erts/doc/src/erl_nif.xml @@ -524,6 +524,18 @@ typedef struct { <p>Note that <c>ErlNifBinary</c> is a semi-opaque type and you are only allowed to read fields <c>size</c> and <c>data</c>.</p> </item> + + <tag><marker id="ErlNifBinaryToTerm"/>ErlNifBinaryToTerm</tag> + <item> + <p>An enumeration of the options that can be given to + <seealso marker="#enif_binary_to_term">enif_binary_to_term</seealso>. + For default behavior, use the value <c>0</c>.</p> + <taglist> + <tag><c>ERL_NIF_BIN2TERM_SAFE</c></tag> + <item><p>Use this option when receiving data from untrusted sources.</p></item> + </taglist> + </item> + <tag><marker id="ErlNifPid"/>ErlNifPid</tag> <item> <p><c>ErlNifPid</c> is a process identifier (pid). In contrast to @@ -532,6 +544,14 @@ typedef struct { <seealso marker="#ErlNifEnv">environment</seealso>. <c>ErlNifPid</c> is an opaque type.</p> </item> + <tag><marker id="ErlNifPort"/>ErlNifPort</tag> + <item> + <p><c>ErlNifPort</c> is a port identifier. In contrast to + port id terms (instances of <c>ERL_NIF_TERM</c>), <c>ErlNifPort</c>'s are self + contained and not bound to any + <seealso marker="#ErlNifEnv">environment</seealso>. <c>ErlNifPort</c> + is an opaque type.</p> + </item> <tag><marker id="ErlNifResourceType"/>ErlNifResourceType</tag> <item> @@ -591,6 +611,21 @@ typedef enum { </taglist> </item> + <tag><marker id="ErlNifUniqueInteger"/>ErlNifUniqueInteger</tag> + <item> + <p>An enumeration of the properties that can be requested from + <seealso marker="#enif_make_unique_integer">enif_unique_integer</seealso>. + For default properties, use the value <c>0</c>.</p> + <taglist> + <tag><c>ERL_NIF_UNIQUE_POSITIVE</c></tag> + <item><p>Return only positive integers</p></item> + <tag><c>ERL_NIF_UNIQUE_MONOTONIC</c></tag> + <item><p>Return only + <seealso marker="time_correction#Strictly_Monotonically_Increasing">strictly + monotonically increasing</seealso> integer corresponding to creation time</p></item> + </taglist> + </item> + </taglist> </section> @@ -632,6 +667,25 @@ typedef enum { have been allocated with <seealso marker="#enif_alloc_env">enif_alloc_env</seealso>. </p></desc> </func> + <func><name><ret>size_t</ret><nametext>enif_binary_to_term(ErlNifEnv *env, const unsigned char* data, size_t size, ERL_NIF_TERM *term, ErlNifBinaryToTerm opts)</nametext></name> + <fsummary>Create a term from the external format</fsummary> + <desc> + <p>Create a term that is the result of decoding the binary data + at <c>data</c>, which must be encoded according to the Erlang external term format. + No more than <c>size</c> bytes are read from <c>data</c>. Argument <c>opts</c> + correspond to the second argument to <seealso marker="erlang#binary_to_term-2"> + <c>erlang:binary_to_term/2</c></seealso>, and must be either <c>0</c> or + <c>ERL_NIF_BIN2TERM_SAFE</c>.</p> + <p>On success, store the resulting term at <c>*term</c> and return + the actual number of bytes read. Return zero if decoding fails or if <c>opts</c> + is invalid.</p> + <p>See also: + <seealso marker="#ErlNifBinaryToTerm"><c>ErlNifBinaryToTerm</c></seealso>, + <seealso marker="erlang#binary_to_term-2"><c>erlang:binary_to_term/2</c></seealso> and + <seealso marker="#enif_term_to_binary"><c>enif_term_to_binary</c></seealso>. + </p> + </desc> + </func> <func><name><ret>int</ret><nametext>enif_compare(ERL_NIF_TERM lhs, ERL_NIF_TERM rhs)</nametext></name> <fsummary>Compare two terms</fsummary> <desc><p>Return an integer less than, equal to, or greater than @@ -689,7 +743,48 @@ typedef enum { a number of repeated NIF-calls without the need to create threads. See also the <seealso marker="#WARNING">warning</seealso> text at the beginning of this document.</p> </desc> + </func> + + <func> + <name><ret>ErlNifTime</ret><nametext>enif_convert_time_unit(ErlNifTime val, ErlNifTimeUnit from, ErlNifTimeUnit to)</nametext></name> + <fsummary>Convert time unit of a time value</fsummary> + <desc> + <marker id="enif_convert_time_unit"></marker> + <p>Arguments:</p> + <taglist> + <tag><c>val</c></tag> + <item>Value to convert time unit for.</item> + <tag><c>from</c></tag> + <item>Time unit of <c>val</c>.</item> + <tag><c>to</c></tag> + <item>Time unit of returned value.</item> + </taglist> + <p>Converts the <c>val</c> value of time unit <c>from</c> to + the corresponding value of time unit <c>to</c>. The result is + rounded using the floor function.</p> + <p>Returns <c>ERL_NIF_TIME_ERROR</c> if called with an invalid + time unit argument.</p> + <p>See also: + <seealso marker="#ErlNifTime"><c>ErlNifTime</c></seealso> and + <seealso marker="#ErlNifTimeUnit"><c>ErlNifTimeUnit</c></seealso>. + </p> + </desc> + </func> + + <func> + <name><ret>ERL_NIF_TERM</ret><nametext>enif_cpu_time(ErlNifEnv *)</nametext></name> + <fsummary></fsummary> + <desc> + <p>Returns the CPU time in the same format as <seealso marker="erlang#timestamp-0">erlang:timestamp()</seealso>. + The CPU time is the time the current logical cpu has spent executing since + some arbitrary point in the past. + If the OS does not support fetching of this value <c>enif_cpu_time</c> + invokes <seealso marker="#enif_make_badarg">enif_make_badarg</seealso>. + </p> + </desc> + </func> + <func><name><ret>int</ret><nametext>enif_equal_tids(ErlNifTid tid1, ErlNifTid tid2)</nametext></name> <fsummary></fsummary> <desc><p>Same as <seealso marker="erl_driver#erl_drv_equal_tids">erl_drv_equal_tids</seealso>. @@ -744,6 +839,12 @@ typedef enum { pid variable <c>*pid</c> from it and return true. Otherwise return false. No check if the process is alive is done.</p></desc> </func> + <func><name><ret>int</ret><nametext>enif_get_local_port(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPort* port_id)</nametext></name> + <fsummary>Read an local port term</fsummary> + <desc><p>If <c>term</c> identifies a node local port, initialize the + port variable <c>*port_id</c> from it and return true. Otherwise return false. + No check if the port is alive is done.</p></desc> + </func> <func><name><ret>int</ret><nametext>enif_get_list_cell(ErlNifEnv* env, ERL_NIF_TERM list, ERL_NIF_TERM* head, ERL_NIF_TERM* tail)</nametext></name> <fsummary>Get head and tail from a list</fsummary> <desc><p>Set <c>*head</c> and <c>*tail</c> from @@ -912,6 +1013,17 @@ typedef enum { <fsummary>Determine if a term is a port</fsummary> <desc><p>Return true if <c>term</c> is a port.</p></desc> </func> + <func><name><ret>int</ret><nametext>enif_is_port_alive(ErlNifEnv* env, ErlNifPort *port_id)</nametext></name> + <fsummary>Determine if a local port is alive or not.</fsummary> + <desc><p>Return true if <c>port_id</c> is currently alive.</p> + <p>This function can only be used in a from a NIF-calling thread.</p></desc> + </func> + <func><name><ret>int</ret><nametext>enif_is_process_alive(ErlNifEnv* env, ErlNifPid *pid)</nametext></name> + <fsummary>Determine if a local process is alive or not.</fsummary> + <desc><p>Return true if <c>pid</c> is currently alive.</p> + <p>This function is only thread-safe when the emulator with SMP support is used. + It can only be used in a non-SMP emulator from a NIF-calling thread.</p></desc> + </func> <func><name><ret>int</ret><nametext>enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term)</nametext></name> <fsummary>Determine if a term is a reference</fsummary> <desc><p>Return true if <c>term</c> is a reference.</p></desc> @@ -961,7 +1073,7 @@ typedef enum { <seealso marker="#enif_is_exception">enif_is_exception</seealso>, but not to any other NIF API function.</p> <p>See also: <seealso marker="#enif_has_pending_exception">enif_has_pending_exception</seealso> - and <seealso marker="#enif_raise_exception">enif_raise_exception</seealso> + and <seealso marker="#enif_raise_exception">enif_raise_exception</seealso>. </p> <note><p>In earlier versions (older than erts-7.0, OTP 18) the return value from <c>enif_make_badarg</c> had to be returned from the NIF. This @@ -1195,6 +1307,23 @@ typedef enum { <fsummary>Create an unsigned integer term</fsummary> <desc><p>Create an integer term from an unsigned 64-bit integer.</p></desc> </func> + <func> + <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_unique_integer(ErlNifEnv *env, ErlNifUniqueInteger properties)</nametext></name> + <fsummary></fsummary> + <desc> + <p>Returns a unique integer with the same properties as given by <seealso marker="erlang#unique_integer-1">erlang:unique_integer/1</seealso>.</p> + <p><c>env</c> is the environment to create the integer in.</p> + <p> + <c>ERL_NIF_UNIQUE_POSITIVE</c> and <c>ERL_NIF_UNIQUE_MONOTONIC</c> can + be passed as the second argument to change the properties of the + integer returned. It is possible to combine them by or:ing the + two values together. + </p> + <p>See also: + <seealso marker="#ErlNifUniqueInteger"><c>ErlNifUniqueInteger</c></seealso>. + </p> + </desc> + </func> <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_ulong(ErlNifEnv* env, unsigned long i)</nametext></name> <fsummary>Create an integer term from an unsigned long int</fsummary> <desc><p>Create an integer term from an <c>unsigned long int</c>.</p></desc> @@ -1265,6 +1394,33 @@ enif_map_iterator_destroy(env, &iter); or false if the iterator is positioned at the head (before the first entry).</p></desc> </func> + + <func> + <name><ret>ErlNifTime</ret><nametext>enif_monotonic_time(ErlNifTimeUnit time_unit)</nametext></name> + <fsummary>Get Erlang Monotonic Time</fsummary> + <desc> + <marker id="enif_monotonic_time"></marker> + <p>Arguments:</p> + <taglist> + <tag><c>time_unit</c></tag> + <item>Time unit of returned value.</item> + </taglist> + <p> + Returns the current + <seealso marker="time_correction#Erlang_Monotonic_Time">Erlang + monotonic time</seealso>. Note that it is not uncommon with + negative values. + </p> + <p>Returns <c>ERL_NIF_TIME_ERROR</c> if called with an invalid + time unit argument, or if called from a thread that is not a + scheduler thread.</p> + <p>See also: + <seealso marker="#ErlNifTime"><c>ErlNifTime</c></seealso> and + <seealso marker="#ErlNifTimeUnit"><c>ErlNifTimeUnit</c></seealso>. + </p> + </desc> + </func> + <func><name><ret>ErlNifMutex *</ret><nametext>enif_mutex_create(char *name)</nametext></name> <fsummary></fsummary> <desc><p>Same as <seealso marker="erl_driver#erl_drv_mutex_create">erl_drv_mutex_create</seealso>. @@ -1290,6 +1446,11 @@ enif_map_iterator_destroy(env, &iter); <desc><p>Same as <seealso marker="erl_driver#erl_drv_mutex_unlock">erl_drv_mutex_unlock</seealso>. </p></desc> </func> + <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_now_time(ErlNifEnv *env)</nametext></name> + <fsummary></fsummary> + <desc><p>Retuns an <seealso marker="erlang#now-0">erlang:now()</seealso> timestamp. + The enif_now_time function is <em>deprecated</em>.</p></desc> + </func> <func><name><ret>ErlNifResourceType *</ret><nametext>enif_open_resource_type(ErlNifEnv* env, const char* module_str, const char* name, ErlNifResourceDtor* dtor, ErlNifResourceFlags flags, ErlNifResourceFlags* tried)</nametext></name> @@ -1319,6 +1480,35 @@ enif_map_iterator_destroy(env, &iter); and <seealso marker="#upgrade">upgrade</seealso>.</p> </desc> </func> + <func><name><ret>int</ret><nametext>enif_port_command(ErlNifEnv* env, const ErlNifPort* to_port, ErlNifEnv *msg_env, ERL_NIF_TERM msg)</nametext></name> + <fsummary>Send a port_command to to_port</fsummary> + <desc> + <p>This function works the same as <seealso marker="erlang#port_command-2">erlang:port_command/2</seealso> + except that it is always completely asynchronous. This call may return false + if it detects that the port is already dead, otherwise it will return true. + </p> + <taglist> + <tag><c>env</c></tag> + <item>The environment of the calling process. May not be NULL.</item> + <tag><c>*to_port</c></tag> + <item>The port id of the receiving port. The port id should refer to a + port on the local node.</item> + <tag><c>msg_env</c></tag> + <item>The environment of the message term. Can be a process + independent environment allocated with + <seealso marker="#enif_alloc_env">enif_alloc_env</seealso> or NULL.</item> + <tag><c>msg</c></tag> + <item>The message term to send. The same limitations apply as on the + payload to <seealso marker="erlang#port_command-2">erlang:port_command/2</seealso>.</item> + </taglist> + <p>Using a <c>msg_env</c> of NULL is an optimization which groups together + calls to <c>enif_alloc_env</c>, <c>enif_make_copy</c>, <c>enif_port_command</c> + and <c>enif_free_env</c> into one call. This optimization is only usefull + when a majority of the terms are to be copied from <c>env</c> to the <c>msg_env</c>.</p> + <p>The call may return false if it detects that the command failed for some reason. Otherwise true is returned.</p> + <p>See also: <seealso marker="#enif_get_local_port"><c>enif_get_local_port</c></seealso>.</p> + </desc> + </func> <func><name><ret>void *</ret><nametext>enif_priv_data(ErlNifEnv* env)</nametext></name> <fsummary>Get the private data of a NIF library</fsummary> <desc><p>Return the pointer to the private data that was set by <c>load</c>, @@ -1453,6 +1643,8 @@ enif_map_iterator_destroy(env, &iter); of cleared for reuse with <seealso marker="#enif_clear_env">enif_clear_env</seealso>.</p> <p>This function is only thread-safe when the emulator with SMP support is used. It can only be used in a non-SMP emulator from a NIF-calling thread.</p> + <note><p>Passing <c>msg_env</c> as <c>NULL</c> is only supported since + erts-8.0 (OTP 19).</p></note> </desc> </func> <func><name><ret>unsigned</ret><nametext>enif_sizeof_resource(void* obj)</nametext></name> @@ -1466,6 +1658,18 @@ enif_map_iterator_destroy(env, &iter); <desc><p>Same as <seealso marker="erl_driver#driver_system_info">driver_system_info</seealso>. </p></desc> </func> + <func><name><ret>int</ret><nametext>enif_term_to_binary(ErlNifEnv *env, ERL_NIF_TERM term, ErlNifBinary *bin)</nametext></name> + <fsummary>Convert a term to the external format</fsummary> + <desc> + <p>Allocates a new binary with <seealso marker="#enif_alloc_binary">enif_alloc_binary</seealso> + and stores the result of encoding <c>term</c> according to the Erlang external term format.</p> + <p>Returns true on success or false if allocation failed.</p> + <p>See also: + <seealso marker="erlang#term_to_binary-1"><c>erlang:term_to_binary/1</c></seealso> and + <seealso marker="#enif_binary_to_term"><c>enif_binary_to_term</c></seealso>. + </p> + </desc> + </func> <func><name><ret>int</ret><nametext>enif_thread_create(char *name,ErlNifTid *tid,void * (*func)(void *),void *args,ErlNifThreadOpts *opts)</nametext></name> <fsummary></fsummary> <desc><p>Same as <seealso marker="erl_driver#erl_drv_thread_create">erl_drv_thread_create</seealso>. @@ -1496,54 +1700,6 @@ enif_map_iterator_destroy(env, &iter); <desc><p>Same as <seealso marker="erl_driver#erl_drv_thread_self">erl_drv_thread_self</seealso>. </p></desc> </func> - <func><name><ret>int</ret><nametext>enif_tsd_key_create(char *name, ErlNifTSDKey *key)</nametext></name> - <fsummary></fsummary> - <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_key_create">erl_drv_tsd_key_create</seealso>. - </p></desc> - </func> - <func><name><ret>void</ret><nametext>enif_tsd_key_destroy(ErlNifTSDKey key)</nametext></name> - <fsummary></fsummary> - <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_key_destroy">erl_drv_tsd_key_destroy</seealso>. - </p></desc> - </func> - <func><name><ret>void *</ret><nametext>enif_tsd_get(ErlNifTSDKey key)</nametext></name> - <fsummary></fsummary> - <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_get">erl_drv_tsd_get</seealso>. - </p></desc> - </func> - <func><name><ret>void</ret><nametext>enif_tsd_set(ErlNifTSDKey key, void *data)</nametext></name> - <fsummary></fsummary> - <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_set">erl_drv_tsd_set</seealso>. - </p></desc> - </func> - - - <func> - <name><ret>ErlNifTime</ret><nametext>enif_monotonic_time(ErlNifTimeUnit time_unit)</nametext></name> - <fsummary>Get Erlang Monotonic Time</fsummary> - <desc> - <marker id="enif_monotonic_time"></marker> - <p>Arguments:</p> - <taglist> - <tag><c>time_unit</c></tag> - <item>Time unit of returned value.</item> - </taglist> - <p> - Returns - <seealso marker="time_correction#Erlang_Monotonic_Time">Erlang - monotonic time</seealso>. Note that it is not uncommon with - negative values. - </p> - <p>Returns <c>ERL_NIF_TIME_ERROR</c> if called with an invalid - time unit argument, or if called from a thread that is not a - scheduler thread.</p> - <p>See also:</p> - <list> - <item><seealso marker="#ErlNifTime"><c>ErlNifTime</c></seealso></item> - <item><seealso marker="#ErlNifTimeUnit"><c>ErlNifTimeUnit</c></seealso></item> - </list> - </desc> - </func> <func> <name><ret>ErlNifTime</ret><nametext>enif_time_offset(ErlNifTimeUnit time_unit)</nametext></name> @@ -1563,41 +1719,33 @@ enif_map_iterator_destroy(env, &iter); <p>Returns <c>ERL_NIF_TIME_ERROR</c> if called with an invalid time unit argument, or if called from a thread that is not a scheduler thread.</p> - <p>See also:</p> - <list> - <item><seealso marker="#ErlNifTime"><c>ErlNifTime</c></seealso></item> - <item><seealso marker="#ErlNifTimeUnit"><c>ErlNifTimeUnit</c></seealso></item> - </list> + <p>See also: + <seealso marker="#ErlNifTime"><c>ErlNifTime</c></seealso> and + <seealso marker="#ErlNifTimeUnit"><c>ErlNifTimeUnit</c></seealso>. + </p> </desc> </func> - <func> - <name><ret>ErlNifTime</ret><nametext>enif_convert_time_unit(ErlNifTime val, ErlNifTimeUnit from, ErlNifTimeUnit to)</nametext></name> - <fsummary>Convert time unit of a time value</fsummary> - <desc> - <marker id="enif_convert_time_unit"></marker> - <p>Arguments:</p> - <taglist> - <tag><c>val</c></tag> - <item>Value to convert time unit for.</item> - <tag><c>from</c></tag> - <item>Time unit of <c>val</c>.</item> - <tag><c>to</c></tag> - <item>Time unit of returned value.</item> - </taglist> - <p>Converts the <c>val</c> value of time unit <c>from</c> to - the corresponding value of time unit <c>to</c>. The result is - rounded using the floor function.</p> - <p>Returns <c>ERL_NIF_TIME_ERROR</c> if called with an invalid - time unit argument.</p> - <p>See also:</p> - <list> - <item><seealso marker="#ErlNifTime"><c>ErlNifTime</c></seealso></item> - <item><seealso marker="#ErlNifTimeUnit"><c>ErlNifTimeUnit</c></seealso></item> - </list> - </desc> + <func><name><ret>int</ret><nametext>enif_tsd_key_create(char *name, ErlNifTSDKey *key)</nametext></name> + <fsummary></fsummary> + <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_key_create">erl_drv_tsd_key_create</seealso>. + </p></desc> + </func> + <func><name><ret>void</ret><nametext>enif_tsd_key_destroy(ErlNifTSDKey key)</nametext></name> + <fsummary></fsummary> + <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_key_destroy">erl_drv_tsd_key_destroy</seealso>. + </p></desc> + </func> + <func><name><ret>void *</ret><nametext>enif_tsd_get(ErlNifTSDKey key)</nametext></name> + <fsummary></fsummary> + <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_get">erl_drv_tsd_get</seealso>. + </p></desc> + </func> + <func><name><ret>void</ret><nametext>enif_tsd_set(ErlNifTSDKey key, void *data)</nametext></name> + <fsummary></fsummary> + <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_set">erl_drv_tsd_set</seealso>. + </p></desc> </func> - </funcs> <section> <title>SEE ALSO</title> diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c index 5d471d168b..74c9d3ee53 100644 --- a/erts/emulator/beam/beam_bp.c +++ b/erts/emulator/beam/beam_bp.c @@ -974,7 +974,7 @@ erts_trace_time_call(Process* c_p, BeamInstr* I, BpDataTime* bdt) if (pbt == 0) { /* First call of process to instrumented function */ pbt = Alloc(sizeof(process_breakpoint_time_t)); - (void) ERTS_PROC_SET_CALL_TIME(c_p, ERTS_PROC_LOCK_MAIN, pbt); + (void) ERTS_PROC_SET_CALL_TIME(c_p, pbt); } else { ASSERT(pbt->pc); /* add time to previous code */ @@ -1598,9 +1598,7 @@ bp_time_unref(BpDataTime* bdt) h_p = erts_pid2proc(NULL, 0, item->pid, ERTS_PROC_LOCK_MAIN); if (h_p) { - pbt = ERTS_PROC_SET_CALL_TIME(h_p, - ERTS_PROC_LOCK_MAIN, - NULL); + pbt = ERTS_PROC_SET_CALL_TIME(h_p, NULL); if (pbt) { Free(pbt); } diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c index f115df935f..d3d278fb81 100644 --- a/erts/emulator/beam/beam_load.c +++ b/erts/emulator/beam/beam_load.c @@ -1548,7 +1548,7 @@ read_literal_table(LoaderState* stp) erts_factory_heap_frag_init(&factory, new_literal_fragment(heap_size)); factory.alloc_type = ERTS_ALC_T_PREPARED_CODE; - val = erts_decode_ext(&factory, &p); + val = erts_decode_ext(&factory, &p, 0); if (is_non_value(val)) { LoadError1(stp, "literal %d: bad external format", i); @@ -1559,7 +1559,7 @@ read_literal_table(LoaderState* stp) } else { erts_factory_dummy_init(&factory); - val = erts_decode_ext(&factory, &p); + val = erts_decode_ext(&factory, &p, 0); if (is_non_value(val)) { LoadError1(stp, "literal %d: bad external format", i); } @@ -5719,7 +5719,7 @@ attributes_for_module(Process* p, /* Process whose heap to use. */ if (ext != NULL) { ErtsHeapFactory factory; erts_factory_proc_prealloc_init(&factory, p, code_hdr->attr_size_on_heap); - result = erts_decode_ext(&factory, &ext); + result = erts_decode_ext(&factory, &ext, 0); if (is_value(result)) { erts_factory_close(&factory); } @@ -5742,7 +5742,7 @@ compilation_info_for_module(Process* p, /* Process whose heap to use. */ if (ext != NULL) { ErtsHeapFactory factory; erts_factory_proc_prealloc_init(&factory, p, code_hdr->compile_size_on_heap); - result = erts_decode_ext(&factory, &ext); + result = erts_decode_ext(&factory, &ext, 0); if (is_value(result)) { erts_factory_close(&factory); } diff --git a/erts/emulator/beam/bif.c b/erts/emulator/beam/bif.c index 37bb28c6f8..97d690db9f 100644 --- a/erts/emulator/beam/bif.c +++ b/erts/emulator/beam/bif.c @@ -1567,7 +1567,7 @@ static BIF_RETTYPE process_flag_aux(Process *BIF_P, scb->n = 0; } - scb = ERTS_PROC_SET_SAVED_CALLS_BUF(rp, ERTS_PROC_LOCK_MAIN, scb); + scb = ERTS_PROC_SET_SAVED_CALLS_BUF(rp, scb); if (!scb) old_value = make_small(0); @@ -1595,9 +1595,7 @@ BIF_RETTYPE process_flag_2(BIF_ALIST_2) if (is_not_atom(BIF_ARG_2)) { goto error; } - old_value = erts_proc_set_error_handler(BIF_P, - ERTS_PROC_LOCK_MAIN, - BIF_ARG_2); + old_value = erts_proc_set_error_handler(BIF_P, BIF_ARG_2); BIF_RET(old_value); } else if (BIF_ARG_1 == am_priority) { diff --git a/erts/emulator/beam/erl_alloc.types b/erts/emulator/beam/erl_alloc.types index 2932adca84..14067283bd 100644 --- a/erts/emulator/beam/erl_alloc.types +++ b/erts/emulator/beam/erl_alloc.types @@ -343,6 +343,8 @@ type SSB SHORT_LIVED PROCESSES ssb +endif +type DEBUG SHORT_LIVED SYSTEM debugging + type DDLL_PROCESS STANDARD SYSTEM ddll_processes type MONITOR_LH STANDARD PROCESSES monitor_lh type NLINK_LH STANDARD PROCESSES nlink_lh diff --git a/erts/emulator/beam/erl_bif_unique.c b/erts/emulator/beam/erl_bif_unique.c index c4a39b8897..c9c8561f64 100644 --- a/erts/emulator/beam/erl_bif_unique.c +++ b/erts/emulator/beam/erl_bif_unique.c @@ -266,17 +266,19 @@ static ERTS_INLINE Eterm unique_integer_bif(Process *c_p, int positive) } Uint -erts_raw_unique_integer_heap_size(Uint64 val[ERTS_UNIQUE_INT_RAW_VALUES]) +erts_raw_unique_integer_heap_size(Uint64 val[ERTS_UNIQUE_INT_RAW_VALUES], + int positive) { Uint sz; - bld_unique_integer_term(NULL, &sz, val[0], val[1], 0); + bld_unique_integer_term(NULL, &sz, val[0], val[1], positive); return sz; } Eterm -erts_raw_make_unique_integer(Eterm **hpp, Uint64 val[ERTS_UNIQUE_INT_RAW_VALUES]) +erts_raw_make_unique_integer(Eterm **hpp, Uint64 val[ERTS_UNIQUE_INT_RAW_VALUES], + int positive) { - return bld_unique_integer_term(hpp, NULL, val[0], val[1], 0); + return bld_unique_integer_term(hpp, NULL, val[0], val[1], positive); } void @@ -426,16 +428,16 @@ erts_raw_get_unique_monotonic_integer(void) } Uint -erts_raw_unique_monotonic_integer_heap_size(Sint64 raw) +erts_raw_unique_monotonic_integer_heap_size(Sint64 raw, int positive) { - return get_unique_monotonic_integer_heap_size(raw, 0); + return get_unique_monotonic_integer_heap_size(raw, positive); } Eterm -erts_raw_make_unique_monotonic_integer_value(Eterm **hpp, Sint64 raw) +erts_raw_make_unique_monotonic_integer_value(Eterm **hpp, Sint64 raw, int positive) { - Uint hsz = get_unique_monotonic_integer_heap_size(raw, 0); - Eterm res = make_unique_monotonic_integer_value(*hpp, hsz, raw, 0); + Uint hsz = get_unique_monotonic_integer_heap_size(raw, positive); + Eterm res = make_unique_monotonic_integer_value(*hpp, hsz, raw, positive); *hpp += hsz; return res; } diff --git a/erts/emulator/beam/erl_bif_unique.h b/erts/emulator/beam/erl_bif_unique.h index 37d5d91c39..94fd6163f2 100644 --- a/erts/emulator/beam/erl_bif_unique.h +++ b/erts/emulator/beam/erl_bif_unique.h @@ -41,8 +41,9 @@ void erts_make_ref_in_array(Uint32 ref[ERTS_MAX_REF_NUMBERS]); * not necessarily correspond to the end result. */ Sint64 erts_raw_get_unique_monotonic_integer(void); -Uint erts_raw_unique_monotonic_integer_heap_size(Sint64 raw); -Eterm erts_raw_make_unique_monotonic_integer_value(Eterm **hpp, Sint64 raw); +Uint erts_raw_unique_monotonic_integer_heap_size(Sint64 raw, int positive); +Eterm erts_raw_make_unique_monotonic_integer_value(Eterm **hpp, Sint64 raw, + int positive); Sint64 erts_get_min_unique_monotonic_integer(void); @@ -53,8 +54,11 @@ Eterm erts_debug_get_unique_monotonic_integer_state(Process *c_p); #define ERTS_UNIQUE_INT_RAW_VALUES 2 #define ERTS_MAX_UNIQUE_INT_HEAP_SIZE ERTS_UINT64_ARRAY_TO_BIG_MAX_HEAP_SZ(2) -Uint erts_raw_unique_integer_heap_size(Uint64 val[ERTS_UNIQUE_INT_RAW_VALUES]); -Eterm erts_raw_make_unique_integer(Eterm **hpp, Uint64 val[ERTS_UNIQUE_INT_RAW_VALUES]); +Uint erts_raw_unique_integer_heap_size(Uint64 val[ERTS_UNIQUE_INT_RAW_VALUES], + int positive); +Eterm erts_raw_make_unique_integer(Eterm **hpp, + Uint64 val[ERTS_UNIQUE_INT_RAW_VALUES], + int postive); void erts_raw_get_unique_integer(Uint64 val[ERTS_UNIQUE_INT_RAW_VALUES]); Sint64 erts_get_min_unique_integer(void); diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c index 8580bc2689..d3030070b7 100644 --- a/erts/emulator/beam/erl_nif.c +++ b/erts/emulator/beam/erl_nif.c @@ -209,6 +209,7 @@ static void flush_env(ErlNifEnv* env) */ static void cache_env(ErlNifEnv* env) { + env->heap_frag = MBUF(env->proc); if (env->heap_frag == NULL) { ASSERT(env->hp_end == HEAP_LIMIT(env->proc)); ASSERT(env->hp <= HEAP_TOP(env->proc)); @@ -216,10 +217,6 @@ static void cache_env(ErlNifEnv* env) env->hp = HEAP_TOP(env->proc); } else { - ASSERT(env->hp_end != HEAP_LIMIT(env->proc)); - ASSERT(env->hp_end - env->hp <= env->heap_frag->alloc_size); - env->heap_frag = MBUF(env->proc); - ASSERT(env->heap_frag != NULL); env->hp = env->heap_frag->mem + env->heap_frag->used_size; env->hp_end = env->heap_frag->mem + env->heap_frag->alloc_size; } @@ -375,6 +372,29 @@ int enif_send(ErlNifEnv* env, const ErlNifPid* to_pid, return 1; } +int +enif_port_command(ErlNifEnv *env, const ErlNifPort* to_port, + ErlNifEnv *msg_env, ERL_NIF_TERM msg) +{ + + ErtsSchedulerData *esdp = erts_get_scheduler_data(); + int scheduler = esdp ? esdp->no : 0; + Port *prt; + + if (scheduler == 0 || !env) + return 0; + + prt = erts_port_lookup(to_port->port_id, + (erts_port_synchronous_ops + ? ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP + : ERTS_PORT_SFLGS_INVALID_LOOKUP)); + + if (!prt) + return 0; + + return erts_port_output_async(prt, env->proc->common.id, msg); +} + ERL_NIF_TERM enif_make_copy(ErlNifEnv* dst_env, ERL_NIF_TERM src_term) { Uint sz; @@ -404,12 +424,28 @@ static int is_offheap(const ErlOffHeap* oh) ErlNifPid* enif_self(ErlNifEnv* caller_env, ErlNifPid* pid) { + if (caller_env->proc->common.id == ERTS_INVALID_PID) + return NULL; pid->pid = caller_env->proc->common.id; return pid; } + int enif_get_local_pid(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPid* pid) { - return is_internal_pid(term) ? (pid->pid=term, 1) : 0; + if (is_internal_pid(term)) { + pid->pid=term; + return 1; + } + return 0; +} + +int enif_get_local_port(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPort* port) +{ + if (is_internal_port(term)) { + port->port_id=term; + return 1; + } + return 0; } int enif_is_atom(ErlNifEnv* env, ERL_NIF_TERM term) @@ -622,6 +658,68 @@ unsigned char* enif_make_new_binary(ErlNifEnv* env, size_t size, return binary_bytes(*termp); } +int enif_term_to_binary(ErlNifEnv *dst_env, ERL_NIF_TERM term, + ErlNifBinary *bin) +{ + Sint size; + byte *bp; + Binary* refbin; + + size = erts_encode_ext_size(term); + if (!enif_alloc_binary(size, bin)) + return 0; + + refbin = bin->ref_bin; + + bp = bin->data; + + erts_encode_ext(term, &bp); + + bin->size = bp - bin->data; + refbin->orig_size = bin->size; + + ASSERT(bin->data + bin->size == bp); + + return 1; +} + +size_t enif_binary_to_term(ErlNifEnv *dst_env, + const unsigned char* data, + size_t data_sz, + ERL_NIF_TERM *term, + ErlNifBinaryToTerm opts) +{ + Sint size; + ErtsHeapFactory factory; + byte *bp = (byte*) data; + + ERTS_CT_ASSERT(ERL_NIF_BIN2TERM_SAFE == ERTS_DIST_EXT_BTT_SAFE); + + if (opts & ~ERL_NIF_BIN2TERM_SAFE) { + return 0; + } + if ((size = erts_decode_ext_size(bp, data_sz)) < 0) + return 0; + + if (size > 0) { + flush_env(dst_env); + erts_factory_proc_prealloc_init(&factory, dst_env->proc, size); + } else { + erts_factory_dummy_init(&factory); + } + + *term = erts_decode_ext(&factory, &bp, (Uint32)opts); + + if (is_non_value(*term)) { + return 0; + } + erts_factory_close(&factory); + cache_env(dst_env); + + ASSERT(bp > data); + return bp - data; +} + int enif_is_identical(Eterm lhs, Eterm rhs) { return EQ(lhs,rhs); @@ -1158,6 +1256,103 @@ int enif_make_reverse_list(ErlNifEnv* env, ERL_NIF_TERM term, ERL_NIF_TERM *list return 1; } +int enif_is_process_alive(ErlNifEnv* env, ErlNifPid *proc) +{ + ErtsProcLocks rp_locks = 0; /* We don't need any locks, + just to check if it is alive */ + Eterm target = proc->pid; + Process* rp; + Process* c_p; + int scheduler = erts_get_scheduler_id() != 0; + + if (env != NULL) { + c_p = env->proc; + if (target == c_p->common.id) { + /* We are alive! */ + return 1; + } + } + else { +#ifdef ERTS_SMP + c_p = NULL; +#else + erts_exit(ERTS_ABORT_EXIT,"enif_is_process_alive: " + "env==NULL on non-SMP VM"); +#endif + } + + rp = (scheduler + ? erts_proc_lookup(target) + : erts_pid2proc_opt(c_p, ERTS_PROC_LOCK_MAIN, + target, rp_locks, ERTS_P2P_FLG_INC_REFC)); + if (rp == NULL) { + ASSERT(env == NULL || target != c_p->common.id); + return 0; + } else { + if (!scheduler) + erts_proc_dec_refc(rp); + return 1; + } +} + +int enif_is_port_alive(ErlNifEnv *env, ErlNifPort *port) +{ + /* only allowed if called from scheduler */ + if (erts_get_scheduler_id() == 0) + erts_exit(ERTS_ABORT_EXIT,"enif_is_port_alive: called from non-scheduler"); + + return erts_port_lookup( + port->port_id, + (erts_port_synchronous_ops + ? ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP + : ERTS_PORT_SFLGS_INVALID_LOOKUP)) != NULL; +} + +ERL_NIF_TERM +enif_now_time(ErlNifEnv *env) +{ + Uint mega, sec, micro; + Eterm *hp; + get_now(&mega, &sec, µ); + hp = alloc_heap(env, 4); + return TUPLE3(hp, make_small(mega), make_small(sec), make_small(micro)); +} + +ERL_NIF_TERM +enif_cpu_time(ErlNifEnv *env) +{ +#ifdef HAVE_ERTS_NOW_CPU + Uint mega, sec, micro; + Eterm *hp; + erts_get_now_cpu(&mega, &sec, µ); + hp = alloc_heap(env, 4); + return TUPLE3(hp, make_small(mega), make_small(sec), make_small(micro)); +#else + return enif_make_badarg(env); +#endif +} + +ERL_NIF_TERM +enif_make_unique_integer(ErlNifEnv *env, ErlNifUniqueInteger properties) +{ + int monotonic = properties & ERL_NIF_UNIQUE_MONOTONIC; + int positive = properties & ERL_NIF_UNIQUE_POSITIVE; + Eterm *hp; + Uint hsz; + + if (monotonic) { + Sint64 raw_unique = erts_raw_get_unique_monotonic_integer(); + hsz = erts_raw_unique_monotonic_integer_heap_size(raw_unique, positive); + hp = alloc_heap(env, hsz); + return erts_raw_make_unique_monotonic_integer_value(&hp, raw_unique, positive); + } else { + Uint64 raw_unique[ERTS_UNIQUE_INT_RAW_VALUES]; + erts_raw_get_unique_integer(raw_unique); + hsz = erts_raw_unique_integer_heap_size(raw_unique, positive); + hp = alloc_heap(env, hsz); + return erts_raw_make_unique_integer(&hp, raw_unique, positive); + } +} ErlNifMutex* enif_mutex_create(char *name) { return erl_drv_mutex_create(name); } void enif_mutex_destroy(ErlNifMutex *mtx) { erl_drv_mutex_destroy(mtx); } @@ -1653,7 +1848,7 @@ allocate_nif_sched_data(Process* proc, int argc) ep->exp.addressv[i] = &ep->exp.code[3]; } ep->exp.code[3] = (BeamInstr) em_call_nif; - (void) ERTS_PROC_SET_NIF_TRAP_EXPORT(proc, ERTS_PROC_LOCK_MAIN, ep); + (void) ERTS_PROC_SET_NIF_TRAP_EXPORT(proc, ep); return ep; } diff --git a/erts/emulator/beam/erl_nif.h b/erts/emulator/beam/erl_nif.h index c9c8b1d0af..bc1f59bc90 100644 --- a/erts/emulator/beam/erl_nif.h +++ b/erts/emulator/beam/erl_nif.h @@ -150,7 +150,12 @@ typedef enum typedef struct { ERL_NIF_TERM pid; /* internal, may change */ -}ErlNifPid; +} ErlNifPid; + +typedef struct +{ + ERL_NIF_TERM port_id; /* internal, may change */ +}ErlNifPort; typedef ErlDrvSysInfo ErlNifSysInfo; @@ -197,6 +202,15 @@ typedef enum { ERL_NIF_MAP_ITERATOR_TAIL = ERL_NIF_MAP_ITERATOR_LAST } ErlNifMapIteratorEntry; +typedef enum { + ERL_NIF_UNIQUE_POSITIVE = (1 << 0), + ERL_NIF_UNIQUE_MONOTONIC = (1 << 1) +} ErlNifUniqueInteger; + +typedef enum { + ERL_NIF_BIN2TERM_SAFE = 0x20000000 +} ErlNifBinaryToTerm; + #if (defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_)) # define ERL_NIF_API_FUNC_DECL(RET_TYPE, NAME, ARGS) RET_TYPE (*NAME) ARGS typedef struct { diff --git a/erts/emulator/beam/erl_nif_api_funcs.h b/erts/emulator/beam/erl_nif_api_funcs.h index 1448a508a2..35058afe7c 100644 --- a/erts/emulator/beam/erl_nif_api_funcs.h +++ b/erts/emulator/beam/erl_nif_api_funcs.h @@ -163,6 +163,15 @@ ERL_NIF_API_FUNC_DECL(int,enif_getenv,(const char* key, char* value, size_t* val ERL_NIF_API_FUNC_DECL(ErlNifTime, enif_monotonic_time, (ErlNifTimeUnit)); ERL_NIF_API_FUNC_DECL(ErlNifTime, enif_time_offset, (ErlNifTimeUnit)); ERL_NIF_API_FUNC_DECL(ErlNifTime, enif_convert_time_unit, (ErlNifTime, ErlNifTimeUnit, ErlNifTimeUnit)); +ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM, enif_now_time, (ErlNifEnv *env)); +ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM, enif_cpu_time, (ErlNifEnv *env)); +ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM, enif_make_unique_integer, (ErlNifEnv *env, ErlNifUniqueInteger properties)); +ERL_NIF_API_FUNC_DECL(int, enif_is_process_alive, (ErlNifEnv *env, ErlNifPid *pid)); +ERL_NIF_API_FUNC_DECL(int, enif_is_port_alive, (ErlNifEnv *env, ErlNifPort *port_id)); +ERL_NIF_API_FUNC_DECL(int, enif_get_local_port, (ErlNifEnv* env, ERL_NIF_TERM, ErlNifPort* port_id)); +ERL_NIF_API_FUNC_DECL(int, enif_term_to_binary, (ErlNifEnv *env, ERL_NIF_TERM term, ErlNifBinary *bin)); +ERL_NIF_API_FUNC_DECL(size_t, enif_binary_to_term, (ErlNifEnv *env, const unsigned char* data, size_t sz, ERL_NIF_TERM *term, unsigned int opts)); +ERL_NIF_API_FUNC_DECL(int, enif_port_command, (ErlNifEnv *env, const ErlNifPort* to_port, ErlNifEnv *msg_env, ERL_NIF_TERM msg)); /* ** ADD NEW ENTRIES HERE (before this comment) !!! @@ -318,6 +327,15 @@ ERL_NIF_API_FUNC_DECL(int,enif_is_on_dirty_scheduler,(ErlNifEnv*)); # define enif_monotonic_time ERL_NIF_API_FUNC_MACRO(enif_monotonic_time) # define enif_time_offset ERL_NIF_API_FUNC_MACRO(enif_time_offset) # define enif_convert_time_unit ERL_NIF_API_FUNC_MACRO(enif_convert_time_unit) +# define enif_now_time ERL_NIF_API_FUNC_MACRO(enif_now_time) +# define enif_cpu_time ERL_NIF_API_FUNC_MACRO(enif_cpu_time) +# define enif_make_unique_integer ERL_NIF_API_FUNC_MACRO(enif_make_unique_integer) +# define enif_is_process_alive ERL_NIF_API_FUNC_MACRO(enif_is_process_alive) +# define enif_is_port_alive ERL_NIF_API_FUNC_MACRO(enif_is_port_alive) +# define enif_get_local_port ERL_NIF_API_FUNC_MACRO(enif_get_local_port) +# define enif_term_to_binary ERL_NIF_API_FUNC_MACRO(enif_term_to_binary) +# define enif_binary_to_term ERL_NIF_API_FUNC_MACRO(enif_binary_to_term) +# define enif_port_command ERL_NIF_API_FUNC_MACRO(enif_port_command) /* ** ADD NEW ENTRIES HERE (before this comment) diff --git a/erts/emulator/beam/erl_port.h b/erts/emulator/beam/erl_port.h index fa97707a87..5b06bc7fd1 100644 --- a/erts/emulator/beam/erl_port.h +++ b/erts/emulator/beam/erl_port.h @@ -185,7 +185,7 @@ struct _erl_drv_port { int control_flags; /* Flags for port_control() */ ErlDrvPDL port_data_lock; - ErtsPrtSD *psd; /* Port specific data */ + erts_smp_atomic_t psd; /* Port specific data */ int reds; /* Only used while executing driver callbacks */ struct { @@ -252,22 +252,51 @@ ERTS_GLB_INLINE void *erts_prtsd_set(Port *p, int ix, void *new); ERTS_GLB_INLINE void * erts_prtsd_get(Port *prt, int ix) { - return prt->psd ? prt->psd->data[ix] : NULL; + ErtsPrtSD *psd = (ErtsPrtSD *) erts_smp_atomic_read_nob(&prt->psd); + if (!psd) + return NULL; + ERTS_SMP_DATA_DEPENDENCY_READ_MEMORY_BARRIER; + return psd->data[ix]; } ERTS_GLB_INLINE void * erts_prtsd_set(Port *prt, int ix, void *data) { - if (prt->psd) { - void *old = prt->psd->data[ix]; - prt->psd->data[ix] = data; + ErtsPrtSD *psd, *new_psd; + void *old; + int i; + + psd = (ErtsPrtSD *) erts_smp_atomic_read_nob(&prt->psd); + + if (psd) { +#ifdef ERTS_SMP +#ifdef ETHR_ORDERED_READ_DEPEND + ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore); +#else + ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreStore); +#endif +#endif + old = psd->data[ix]; + psd->data[ix] = data; return old; } - else { - prt->psd = erts_alloc(ERTS_ALC_T_PRTSD, sizeof(ErtsPrtSD)); - prt->psd->data[ix] = data; + + if (!data) return NULL; - } + + new_psd = erts_alloc(ERTS_ALC_T_PRTSD, sizeof(ErtsPrtSD)); + for (i = 0; i < ERTS_PRTSD_SIZE; i++) + new_psd->data[i] = NULL; + psd = (ErtsPrtSD *) erts_smp_atomic_cmpxchg_mb(&prt->psd, + (erts_aint_t) new_psd, + (erts_aint_t) NULL); + if (psd) + erts_free(ERTS_ALC_T_PRTSD, new_psd); + else + psd = new_psd; + old = psd->data[ix]; + psd->data[ix] = data; + return old; } #endif @@ -949,6 +978,8 @@ ErtsPortOpResult erts_port_control(Process *, Port *, unsigned int, Eterm, Eterm ErtsPortOpResult erts_port_call(Process *, Port *, unsigned int, Eterm, Eterm *); ErtsPortOpResult erts_port_info(Process *, Port *, Eterm, Eterm *); +int erts_port_output_async(Port *, Eterm, Eterm); + /* * Signals from ports to ports. Used by sys drivers. */ diff --git a/erts/emulator/beam/erl_port_task.c b/erts/emulator/beam/erl_port_task.c index e85395e062..b200344af5 100644 --- a/erts/emulator/beam/erl_port_task.c +++ b/erts/emulator/beam/erl_port_task.c @@ -180,10 +180,9 @@ p2p_sig_data_to_task(ErtsProc2PortSigData *sigdp) return ptp; } -ErtsProc2PortSigData * -erts_port_task_alloc_p2p_sig_data(void) +static ERTS_INLINE ErtsProc2PortSigData * +p2p_sig_data_init(ErtsPortTask *ptp) { - ErtsPortTask *ptp = port_task_alloc(); ptp->type = ERTS_PORT_TASK_PROC_SIG; ptp->u.alive.flags = ERTS_PT_FLG_SIG_DEP; @@ -194,6 +193,31 @@ erts_port_task_alloc_p2p_sig_data(void) return &ptp->u.alive.td.psig.data; } +ErtsProc2PortSigData * +erts_port_task_alloc_p2p_sig_data(void) +{ + ErtsPortTask *ptp = port_task_alloc(); + + return p2p_sig_data_init(ptp); +} + +ErtsProc2PortSigData * +erts_port_task_alloc_p2p_sig_data_extra(size_t extra, void **extra_ptr) +{ + ErtsPortTask *ptp = erts_alloc(ERTS_ALC_T_PORT_TASK, + sizeof(ErtsPortTask) + extra); + + *extra_ptr = ptp+1; + + return p2p_sig_data_init(ptp); +} + +void +erts_port_task_free_p2p_sig_data(ErtsProc2PortSigData *sigdp) +{ + schedule_port_task_free(p2p_sig_data_to_task(sigdp)); +} + static ERTS_INLINE Eterm task_caller(ErtsPortTask *ptp) { diff --git a/erts/emulator/beam/erl_port_task.h b/erts/emulator/beam/erl_port_task.h index 335f7a77d5..56cef4e352 100644 --- a/erts/emulator/beam/erl_port_task.h +++ b/erts/emulator/beam/erl_port_task.h @@ -269,6 +269,8 @@ int erts_port_task_schedule(Eterm, void erts_port_task_free_port(Port *); int erts_port_is_scheduled(Port *); ErtsProc2PortSigData *erts_port_task_alloc_p2p_sig_data(void); +ErtsProc2PortSigData *erts_port_task_alloc_p2p_sig_data_extra(size_t extra, void **extra_ptr); +void erts_port_task_free_p2p_sig_data(ErtsProc2PortSigData *sigdp); #ifdef ERTS_SMP void erts_enqueue_port(ErtsRunQueue *rq, Port *pp); diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c index a706ebf595..1fb8502ebe 100644 --- a/erts/emulator/beam/erl_process.c +++ b/erts/emulator/beam/erl_process.c @@ -687,45 +687,36 @@ erts_pre_init_process(void) = "DEBUG_WAIT_COMPLETED"; #ifdef ERTS_ENABLE_LOCK_CHECK - { - int ix; - erts_psd_required_locks[ERTS_PSD_ERROR_HANDLER].get_locks - = ERTS_PSD_ERROR_HANDLER_BUF_GET_LOCKS; - erts_psd_required_locks[ERTS_PSD_ERROR_HANDLER].set_locks - = ERTS_PSD_ERROR_HANDLER_BUF_SET_LOCKS; + erts_psd_required_locks[ERTS_PSD_ERROR_HANDLER].get_locks + = ERTS_PSD_ERROR_HANDLER_BUF_GET_LOCKS; + erts_psd_required_locks[ERTS_PSD_ERROR_HANDLER].set_locks + = ERTS_PSD_ERROR_HANDLER_BUF_SET_LOCKS; - erts_psd_required_locks[ERTS_PSD_SAVED_CALLS_BUF].get_locks - = ERTS_PSD_SAVED_CALLS_BUF_GET_LOCKS; - erts_psd_required_locks[ERTS_PSD_SAVED_CALLS_BUF].set_locks - = ERTS_PSD_SAVED_CALLS_BUF_SET_LOCKS; + erts_psd_required_locks[ERTS_PSD_SAVED_CALLS_BUF].get_locks + = ERTS_PSD_SAVED_CALLS_BUF_GET_LOCKS; + erts_psd_required_locks[ERTS_PSD_SAVED_CALLS_BUF].set_locks + = ERTS_PSD_SAVED_CALLS_BUF_SET_LOCKS; - erts_psd_required_locks[ERTS_PSD_SCHED_ID].get_locks - = ERTS_PSD_SCHED_ID_GET_LOCKS; - erts_psd_required_locks[ERTS_PSD_SCHED_ID].set_locks - = ERTS_PSD_SCHED_ID_SET_LOCKS; + erts_psd_required_locks[ERTS_PSD_SCHED_ID].get_locks + = ERTS_PSD_SCHED_ID_GET_LOCKS; + erts_psd_required_locks[ERTS_PSD_SCHED_ID].set_locks + = ERTS_PSD_SCHED_ID_SET_LOCKS; - erts_psd_required_locks[ERTS_PSD_CALL_TIME_BP].get_locks - = ERTS_PSD_CALL_TIME_BP_GET_LOCKS; - erts_psd_required_locks[ERTS_PSD_CALL_TIME_BP].set_locks - = ERTS_PSD_CALL_TIME_BP_SET_LOCKS; + erts_psd_required_locks[ERTS_PSD_CALL_TIME_BP].get_locks + = ERTS_PSD_CALL_TIME_BP_GET_LOCKS; + erts_psd_required_locks[ERTS_PSD_CALL_TIME_BP].set_locks + = ERTS_PSD_CALL_TIME_BP_SET_LOCKS; - erts_psd_required_locks[ERTS_PSD_DELAYED_GC_TASK_QS].get_locks - = ERTS_PSD_DELAYED_GC_TASK_QS_GET_LOCKS; - erts_psd_required_locks[ERTS_PSD_DELAYED_GC_TASK_QS].set_locks - = ERTS_PSD_DELAYED_GC_TASK_QS_SET_LOCKS; + erts_psd_required_locks[ERTS_PSD_DELAYED_GC_TASK_QS].get_locks + = ERTS_PSD_DELAYED_GC_TASK_QS_GET_LOCKS; + erts_psd_required_locks[ERTS_PSD_DELAYED_GC_TASK_QS].set_locks + = ERTS_PSD_DELAYED_GC_TASK_QS_SET_LOCKS; - erts_psd_required_locks[ERTS_PSD_NIF_TRAP_EXPORT].get_locks - = ERTS_PSD_NIF_TRAP_EXPORT_GET_LOCKS; - erts_psd_required_locks[ERTS_PSD_NIF_TRAP_EXPORT].set_locks - = ERTS_PSD_NIF_TRAP_EXPORT_SET_LOCKS; - - /* Check that we have locks for all entries */ - for (ix = 0; ix < ERTS_PSD_SIZE; ix++) { - ERTS_SMP_LC_ASSERT(erts_psd_required_locks[ix].get_locks); - ERTS_SMP_LC_ASSERT(erts_psd_required_locks[ix].set_locks); - } - } + erts_psd_required_locks[ERTS_PSD_NIF_TRAP_EXPORT].get_locks + = ERTS_PSD_NIF_TRAP_EXPORT_GET_LOCKS; + erts_psd_required_locks[ERTS_PSD_NIF_TRAP_EXPORT].set_locks + = ERTS_PSD_NIF_TRAP_EXPORT_SET_LOCKS; #endif } @@ -1314,46 +1305,25 @@ erts_proclist_destroy(ErtsProcList *plp) } void * -erts_psd_set_init(Process *p, ErtsProcLocks plocks, int ix, void *data) +erts_psd_set_init(Process *p, int ix, void *data) { void *old; - ErtsProcLocks xplocks; - int refc = 0; - ErtsPSD *psd = erts_alloc(ERTS_ALC_T_PSD, sizeof(ErtsPSD)); + ErtsPSD *psd, *new_psd; int i; - for (i = 0; i < ERTS_PSD_SIZE; i++) - psd->data[i] = NULL; - ERTS_SMP_LC_ASSERT(plocks); - ERTS_SMP_LC_ASSERT(plocks == erts_proc_lc_my_proc_locks(p)); + new_psd = erts_alloc(ERTS_ALC_T_PSD, sizeof(ErtsPSD)); + for (i = 0; i < ERTS_PSD_SIZE; i++) + new_psd->data[i] = NULL; - xplocks = ERTS_PROC_LOCKS_ALL; - xplocks &= ~plocks; - if (xplocks && erts_smp_proc_trylock(p, xplocks) == EBUSY) { - if (xplocks & ERTS_PROC_LOCK_MAIN) { - erts_proc_inc_refc(p); - erts_smp_proc_unlock(p, plocks); - erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL); - refc = 1; - } - else { - if (plocks & ERTS_PROC_LOCKS_ALL_MINOR) - erts_smp_proc_unlock(p, plocks & ERTS_PROC_LOCKS_ALL_MINOR); - erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL_MINOR); - } - } - if (!p->psd) - p->psd = psd; - if (xplocks) - erts_smp_proc_unlock(p, xplocks); - if (refc) - erts_proc_dec_refc(p); - ASSERT(p->psd); - if (p->psd != psd) - erts_free(ERTS_ALC_T_PSD, psd); - old = p->psd->data[ix]; - p->psd->data[ix] = data; - ERTS_SMP_LC_ASSERT(plocks == erts_proc_lc_my_proc_locks(p)); + psd = (ErtsPSD *) erts_smp_atomic_cmpxchg_mb(&p->psd, + (erts_aint_t) new_psd, + (erts_aint_t) NULL); + if (psd) + erts_free(ERTS_ALC_T_PSD, new_psd); + else + psd = new_psd; + old = psd->data[ix]; + psd->data[ix] = data; return old; } @@ -2211,8 +2181,7 @@ setup_thr_debug_wait_completed(void *vproc) if (debug_wait_completed_flags & ERTS_DEBUG_WAIT_COMPLETED_DEALLOCATIONS) { erts_alloc_fix_alloc_shrink(awdp->sched_id, 0); wait_flags |= (ERTS_SSI_AUX_WORK_DD - | ERTS_SSI_AUX_WORK_DD_THR_PRGR - | ERTS_SSI_AUX_WORK_THR_PRGR_LATER_OP); + | ERTS_SSI_AUX_WORK_DD_THR_PRGR); #ifdef ERTS_SMP aux_work_flags |= ERTS_SSI_AUX_WORK_DD; #endif @@ -2220,8 +2189,7 @@ setup_thr_debug_wait_completed(void *vproc) if (debug_wait_completed_flags & ERTS_DEBUG_WAIT_COMPLETED_TIMER_CANCELLATIONS) { wait_flags |= (ERTS_SSI_AUX_WORK_CNCLD_TMRS - | ERTS_SSI_AUX_WORK_CNCLD_TMRS_THR_PRGR - | ERTS_SSI_AUX_WORK_THR_PRGR_LATER_OP); + | ERTS_SSI_AUX_WORK_CNCLD_TMRS_THR_PRGR); #ifdef ERTS_SMP if (awdp->esdp && !ERTS_SCHEDULER_IS_DIRTY(awdp->esdp)) aux_work_flags |= ERTS_SSI_AUX_WORK_CNCLD_TMRS; @@ -2235,26 +2203,42 @@ setup_thr_debug_wait_completed(void *vproc) awdp->debug.wait_completed.arg = vproc; } -static void -prep_setup_thr_debug_wait_completed(void *vproc) +struct debug_lop { + ErtsThrPrgrLaterOp lop; + Process *proc; +}; + +static void later_thr_debug_wait_completed(void *vlop) { + struct debug_lop *lop = vlop; erts_aint32_t count = (erts_aint32_t) erts_no_schedulers; #ifdef ERTS_SMP count += 1; /* aux thread */ #endif if (erts_atomic32_dec_read_mb(&debug_wait_completed_count) == count) { - /* scheduler threads */ - erts_schedule_multi_misc_aux_work(0, - erts_no_schedulers, - setup_thr_debug_wait_completed, - vproc); + /* scheduler threads */ + erts_schedule_multi_misc_aux_work(0, + erts_no_schedulers, + setup_thr_debug_wait_completed, + lop->proc); #ifdef ERTS_SMP - /* aux_thread */ - erts_schedule_misc_aux_work(0, - setup_thr_debug_wait_completed, - vproc); + /* aux_thread */ + erts_schedule_misc_aux_work(0, + setup_thr_debug_wait_completed, + lop->proc); #endif } + erts_free(ERTS_ALC_T_DEBUG, lop); +} + + +static void +init_thr_debug_wait_completed(void *vproc) +{ + struct debug_lop* lop = erts_alloc(ERTS_ALC_T_DEBUG, + sizeof(struct debug_lop)); + lop->proc = vproc; + erts_schedule_thr_prgr_later_op(later_thr_debug_wait_completed, lop, &lop->lop); } @@ -2264,7 +2248,7 @@ erts_debug_wait_completed(Process *c_p, int flags) /* Only one process at a time can do this */ erts_aint32_t count = (erts_aint32_t) (2*erts_no_schedulers); #ifdef ERTS_SMP - count += 2; /* aux thread */ + count += 1; /* aux thread */ #endif if (0 == erts_atomic32_cmpxchg_mb(&debug_wait_completed_count, count, @@ -2272,17 +2256,12 @@ erts_debug_wait_completed(Process *c_p, int flags) debug_wait_completed_flags = flags; erts_suspend(c_p, ERTS_PROC_LOCK_MAIN, NULL); erts_proc_inc_refc(c_p); - /* scheduler threads */ + + /* First flush later-ops on all scheduler threads */ erts_schedule_multi_misc_aux_work(0, erts_no_schedulers, - prep_setup_thr_debug_wait_completed, + init_thr_debug_wait_completed, (void *) c_p); -#ifdef ERTS_SMP - /* aux_thread */ - erts_schedule_misc_aux_work(0, - prep_setup_thr_debug_wait_completed, - (void *) c_p); -#endif return 1; } return 0; @@ -9324,8 +9303,6 @@ Process *schedule(Process *p, int calls) } else { sched_out_proc: - ASSERT(!(p->flags & F_DELAY_GC)); - #ifdef ERTS_SMP ERTS_SMP_CHK_HAVE_ONLY_MAIN_PROC_LOCK(p); esdp = p->scheduler_data; @@ -9789,10 +9766,7 @@ Process *schedule(Process *p, int calls) if (erts_sched_stat.enabled) { int prio; - UWord old = ERTS_PROC_SCHED_ID(p, - (ERTS_PROC_LOCK_MAIN - | ERTS_PROC_LOCK_STATUS), - (UWord) esdp->no); + UWord old = ERTS_PROC_SCHED_ID(p, (UWord) esdp->no); int migrated = old && old != esdp->no; #ifdef ERTS_DIRTY_SCHEDULERS @@ -9886,15 +9860,24 @@ Process *schedule(Process *p, int calls) #endif if (state & ERTS_PSFLG_RUNNING_SYS) { - reds -= execute_sys_tasks(p, &state, reds); - if (reds <= 0 + /* + * GC is normally never delayed when a process + * is scheduled out, but might be when executing + * hand written beam assembly in + * prim_eval:'receive'. If GC is delayed we are + * not allowed to execute system tasks. + */ + if (!(p->flags & F_DELAY_GC)) { + reds -= execute_sys_tasks(p, &state, reds); + if (reds <= 0 #ifdef ERTS_DIRTY_SCHEDULERS - || ERTS_SCHEDULER_IS_DIRTY(esdp) - || (state & ERTS_PSFLGS_DIRTY_WORK) + || ERTS_SCHEDULER_IS_DIRTY(esdp) + || (state & ERTS_PSFLGS_DIRTY_WORK) #endif - ) { - p->fcalls = reds; - goto sched_out_proc; + ) { + p->fcalls = reds; + goto sched_out_proc; + } } ASSERT(state & ERTS_PSFLG_RUNNING_SYS); @@ -9924,7 +9907,7 @@ Process *schedule(Process *p, int calls) } if (ERTS_IS_GC_DESIRED(p)) { - if (!(state & ERTS_PSFLG_EXITING) && !(p->flags & F_DISABLE_GC)) { + if (!(state & ERTS_PSFLG_EXITING) && !(p->flags & (F_DELAY_GC|F_DISABLE_GC))) { reds -= erts_garbage_collect_nobump(p, 0, p->arg_reg, p->arity); if (reds <= 0) { p->fcalls = reds; @@ -10456,7 +10439,7 @@ save_gc_task(Process *c_p, ErtsProcSysTask *st, int prio) qs->q[PRIORITY_NORMAL] = NULL; qs->q[PRIORITY_LOW] = NULL; qs->q[prio] = st; - (void) ERTS_PROC_SET_DELAYED_GC_TASK_QS(c_p, ERTS_PROC_LOCK_MAIN, qs); + (void) ERTS_PROC_SET_DELAYED_GC_TASK_QS(c_p, qs); } else { if (!qs->q[prio]) { @@ -10603,7 +10586,7 @@ erts_set_gc_state(Process *c_p, int enable) erts_smp_proc_unlock(c_p, ERTS_PROC_LOCK_STATUS); - (void) ERTS_PROC_SET_DELAYED_GC_TASK_QS(c_p, ERTS_PROC_LOCK_MAIN, NULL); + (void) ERTS_PROC_SET_DELAYED_GC_TASK_QS(c_p, NULL); if (dgc_tsk_qs) proc_sys_task_queues_free(dgc_tsk_qs); @@ -11089,7 +11072,7 @@ erl_create_process(Process* parent, /* Parent of process (default group leader). p->mbuf = NULL; p->msg_frag = NULL; p->mbuf_sz = 0; - p->psd = NULL; + erts_smp_atomic_init_nob(&p->psd, (erts_aint_t) NULL); p->dictionary = NULL; p->seq_trace_lastcnt = 0; p->seq_trace_clock = 0; @@ -11258,7 +11241,7 @@ void erts_init_empty_process(Process *p) p->mbuf = NULL; p->msg_frag = NULL; p->mbuf_sz = 0; - p->psd = NULL; + erts_smp_atomic_init_nob(&p->psd, (erts_aint_t) NULL); ERTS_P_MONITORS(p) = NULL; ERTS_P_LINKS(p) = NULL; /* List of links */ p->nodes_monitors = NULL; @@ -11428,14 +11411,17 @@ static void delete_process(Process* p) { Eterm *heap; + ErtsPSD *psd; VERBOSE(DEBUG_PROCESSES, ("Removing process: %T\n",p->common.id)); VERBOSE(DEBUG_SHCOPY, ("[pid=%T] delete process: %p %p %p %p\n", p->common.id, HEAP_START(p), HEAP_END(p), OLD_HEAP(p), OLD_HEND(p))); /* Cleanup psd */ - if (p->psd) - erts_free(ERTS_ALC_T_PSD, p->psd); + psd = (ErtsPSD *) erts_smp_atomic_read_nob(&p->psd); + + if (psd) + erts_free(ERTS_ALC_T_PSD, psd); /* Clean binaries and funs */ erts_cleanup_offheap(&p->off_heap); @@ -12514,9 +12500,9 @@ erts_continue_exit_process(Process *p) } dep = (p->flags & F_DISTRIBUTION) ? erts_this_dist_entry : NULL; - scb = ERTS_PROC_SET_SAVED_CALLS_BUF(p, ERTS_PROC_LOCKS_ALL, NULL); - pbt = ERTS_PROC_SET_CALL_TIME(p, ERTS_PROC_LOCKS_ALL, NULL); - nif_export = ERTS_PROC_SET_NIF_TRAP_EXPORT(p, ERTS_PROC_LOCKS_ALL, NULL); + scb = ERTS_PROC_SET_SAVED_CALLS_BUF(p, NULL); + pbt = ERTS_PROC_SET_CALL_TIME(p, NULL); + nif_export = ERTS_PROC_SET_NIF_TRAP_EXPORT(p, NULL); erts_smp_proc_unlock(p, ERTS_PROC_LOCKS_ALL); #ifdef BM_COUNTERS diff --git a/erts/emulator/beam/erl_process.h b/erts/emulator/beam/erl_process.h index c88bd7056c..c07337b325 100644 --- a/erts/emulator/beam/erl_process.h +++ b/erts/emulator/beam/erl_process.h @@ -818,8 +818,8 @@ typedef struct { #define ERTS_PSD_ERROR_HANDLER_BUF_GET_LOCKS ERTS_PROC_LOCK_MAIN #define ERTS_PSD_ERROR_HANDLER_BUF_SET_LOCKS ERTS_PROC_LOCK_MAIN -#define ERTS_PSD_SAVED_CALLS_BUF_GET_LOCKS ERTS_PROC_LOCK_MAIN -#define ERTS_PSD_SAVED_CALLS_BUF_SET_LOCKS ERTS_PROC_LOCK_MAIN +#define ERTS_PSD_SAVED_CALLS_BUF_GET_LOCKS ((ErtsProcLocks) 0) +#define ERTS_PSD_SAVED_CALLS_BUF_SET_LOCKS ((ErtsProcLocks) 0) #define ERTS_PSD_SCHED_ID_GET_LOCKS ERTS_PROC_LOCK_STATUS #define ERTS_PSD_SCHED_ID_SET_LOCKS ERTS_PROC_LOCK_STATUS @@ -830,8 +830,8 @@ typedef struct { #define ERTS_PSD_DELAYED_GC_TASK_QS_GET_LOCKS ERTS_PROC_LOCK_MAIN #define ERTS_PSD_DELAYED_GC_TASK_QS_SET_LOCKS ERTS_PROC_LOCK_MAIN -#define ERTS_PSD_NIF_TRAP_EXPORT_GET_LOCKS ERTS_PROC_LOCK_MAIN -#define ERTS_PSD_NIF_TRAP_EXPORT_SET_LOCKS ERTS_PROC_LOCK_MAIN +#define ERTS_PSD_NIF_TRAP_EXPORT_GET_LOCKS ((ErtsProcLocks) 0) +#define ERTS_PSD_NIF_TRAP_EXPORT_SET_LOCKS ((ErtsProcLocks) 0) typedef struct { ErtsProcLocks get_locks; @@ -1026,7 +1026,7 @@ struct process { ErlHeapFragment* live_hf_end; ErtsMessage *msg_frag; /* Pointer to message fragment list */ Uint mbuf_sz; /* Total size of heap fragments and message fragments */ - ErtsPSD *psd; /* Rarely used process specific data */ + erts_smp_atomic_t psd; /* Rarely used process specific data */ Uint64 bin_vheap_sz; /* Virtual heap block size for binaries */ Uint64 bin_old_vheap_sz; /* Virtual old heap block size for binaries */ @@ -1903,18 +1903,19 @@ do { \ #define ERTS_SMP_LC_CHK_RUNQ_LOCK(RQ, L) #endif -void *erts_psd_set_init(Process *p, ErtsProcLocks plocks, int ix, void *data); +void *erts_psd_set_init(Process *p, int ix, void *data); ERTS_GLB_INLINE void * erts_psd_get(Process *p, int ix); ERTS_GLB_INLINE void * -erts_psd_set(Process *p, ErtsProcLocks plocks, int ix, void *new); +erts_psd_set(Process *p, int ix, void *new); #if ERTS_GLB_INLINE_INCL_FUNC_DEF ERTS_GLB_INLINE void * erts_psd_get(Process *p, int ix) { + ErtsPSD *psd; #if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK) ErtsProcLocks locks = erts_proc_lc_my_proc_locks(p); if (ERTS_LC_PSD_ANY_LOCK == erts_psd_required_locks[ix].get_locks) @@ -1925,17 +1926,19 @@ erts_psd_get(Process *p, int ix) || erts_thr_progress_is_blocking()); } #endif + + psd = (ErtsPSD *) erts_smp_atomic_read_nob(&p->psd); ASSERT(0 <= ix && ix < ERTS_PSD_SIZE); - return p->psd ? p->psd->data[ix] : NULL; + if (!psd) + return NULL; + ERTS_SMP_DATA_DEPENDENCY_READ_MEMORY_BARRIER; + return psd->data[ix]; } - -/* - * NOTE: erts_psd_set() might release and reacquire locks on 'p'. - */ ERTS_GLB_INLINE void * -erts_psd_set(Process *p, ErtsProcLocks plocks, int ix, void *data) +erts_psd_set(Process *p, int ix, void *data) { + ErtsPSD *psd; #if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK) ErtsProcLocks locks = erts_proc_lc_my_proc_locks(p); if (ERTS_LC_PSD_ANY_LOCK == erts_psd_required_locks[ix].set_locks) @@ -1946,50 +1949,56 @@ erts_psd_set(Process *p, ErtsProcLocks plocks, int ix, void *data) || erts_thr_progress_is_blocking()); } #endif + psd = (ErtsPSD *) erts_smp_atomic_read_nob(&p->psd); ASSERT(0 <= ix && ix < ERTS_PSD_SIZE); - if (p->psd) { - void *old = p->psd->data[ix]; - p->psd->data[ix] = data; + if (psd) { + void *old; +#ifdef ERTS_SMP +#ifdef ETHR_ORDERED_READ_DEPEND + ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore); +#else + ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreStore); +#endif +#endif + old = psd->data[ix]; + psd->data[ix] = data; return old; } - else { - if (!data) - return NULL; - else - return erts_psd_set_init(p, plocks, ix, data); - } + + if (!data) + return NULL; + + return erts_psd_set_init(p, ix, data); } #endif -#define ERTS_PROC_SCHED_ID(P, L, ID) \ - ((UWord) erts_psd_set((P), (L), ERTS_PSD_SCHED_ID, (void *) (ID))) +#define ERTS_PROC_SCHED_ID(P, ID) \ + ((UWord) erts_psd_set((P), ERTS_PSD_SCHED_ID, (void *) (ID))) #define ERTS_PROC_GET_SAVED_CALLS_BUF(P) \ ((struct saved_calls *) erts_psd_get((P), ERTS_PSD_SAVED_CALLS_BUF)) -#define ERTS_PROC_SET_SAVED_CALLS_BUF(P, L, SCB) \ - ((struct saved_calls *) erts_psd_set((P), (L), ERTS_PSD_SAVED_CALLS_BUF, (void *) (SCB))) +#define ERTS_PROC_SET_SAVED_CALLS_BUF(P, SCB) \ + ((struct saved_calls *) erts_psd_set((P), ERTS_PSD_SAVED_CALLS_BUF, (void *) (SCB))) #define ERTS_PROC_GET_CALL_TIME(P) \ ((process_breakpoint_time_t *) erts_psd_get((P), ERTS_PSD_CALL_TIME_BP)) -#define ERTS_PROC_SET_CALL_TIME(P, L, PBT) \ - ((process_breakpoint_time_t *) erts_psd_set((P), (L), ERTS_PSD_CALL_TIME_BP, (void *) (PBT))) +#define ERTS_PROC_SET_CALL_TIME(P, PBT) \ + ((process_breakpoint_time_t *) erts_psd_set((P), ERTS_PSD_CALL_TIME_BP, (void *) (PBT))) #define ERTS_PROC_GET_DELAYED_GC_TASK_QS(P) \ ((ErtsProcSysTaskQs *) erts_psd_get((P), ERTS_PSD_DELAYED_GC_TASK_QS)) -#define ERTS_PROC_SET_DELAYED_GC_TASK_QS(P, L, PBT) \ - ((ErtsProcSysTaskQs *) erts_psd_set((P), (L), ERTS_PSD_DELAYED_GC_TASK_QS, (void *) (PBT))) +#define ERTS_PROC_SET_DELAYED_GC_TASK_QS(P, PBT) \ + ((ErtsProcSysTaskQs *) erts_psd_set((P), ERTS_PSD_DELAYED_GC_TASK_QS, (void *) (PBT))) #define ERTS_PROC_GET_NIF_TRAP_EXPORT(P) \ erts_psd_get((P), ERTS_PSD_NIF_TRAP_EXPORT) -#define ERTS_PROC_SET_NIF_TRAP_EXPORT(P, L, NTE) \ - erts_psd_set((P), (L), ERTS_PSD_NIF_TRAP_EXPORT, (void *) (NTE)) +#define ERTS_PROC_SET_NIF_TRAP_EXPORT(P, NTE) \ + erts_psd_set((P), ERTS_PSD_NIF_TRAP_EXPORT, (void *) (NTE)) ERTS_GLB_INLINE Eterm erts_proc_get_error_handler(Process *p); -ERTS_GLB_INLINE Eterm erts_proc_set_error_handler(Process *p, - ErtsProcLocks plocks, - Eterm handler); +ERTS_GLB_INLINE Eterm erts_proc_set_error_handler(Process *p, Eterm handler); #if ERTS_GLB_INLINE_INCL_FUNC_DEF ERTS_GLB_INLINE Eterm @@ -2005,13 +2014,13 @@ erts_proc_get_error_handler(Process *p) } ERTS_GLB_INLINE Eterm -erts_proc_set_error_handler(Process *p, ErtsProcLocks plocks, Eterm handler) +erts_proc_set_error_handler(Process *p, Eterm handler) { void *old_val; void *new_val; ASSERT(is_atom(handler)); new_val = (handler == am_error_handler) ? NULL : (void *) (UWord) handler; - old_val = erts_psd_set(p, plocks, ERTS_PSD_ERROR_HANDLER, new_val); + old_val = erts_psd_set(p, ERTS_PSD_ERROR_HANDLER, new_val); if (!old_val) return am_error_handler; else { diff --git a/erts/emulator/beam/erl_process_dump.c b/erts/emulator/beam/erl_process_dump.c index 39c36ee7a9..73552b28de 100644 --- a/erts/emulator/beam/erl_process_dump.c +++ b/erts/emulator/beam/erl_process_dump.c @@ -103,7 +103,7 @@ Uint erts_process_memory(Process *p, int incl_msg_inq) { size += p->arity * sizeof(p->arg_reg[0]); } - if (p->psd) + if (erts_smp_atomic_read_nob(&p->psd) != (erts_aint_t) NULL) size += sizeof(ErtsPSD); scb = ERTS_PROC_GET_SAVED_CALLS_BUF(p); diff --git a/erts/emulator/beam/erl_term.c b/erts/emulator/beam/erl_term.c index d2343912b4..72a1e0b6ec 100644 --- a/erts/emulator/beam/erl_term.c +++ b/erts/emulator/beam/erl_term.c @@ -59,96 +59,6 @@ erts_set_literal_tag(Eterm *term, Eterm *hp_start, Eterm hsz) #endif } -__decl_noreturn static void __noreturn -et_abort(const char *expr, const char *file, unsigned line) -{ -#ifdef EXIT_ON_ET_ABORT - static int have_been_called = 0; - - if (have_been_called) { - abort(); - } else { - /* - * Prevent infinite loop. - */ - have_been_called = 1; - erts_exit(ERTS_ERROR_EXIT, "TYPE ASSERTION FAILED, file %s, line %u: %s\n", file, line, expr); - } -#else - erts_fprintf(stderr, "TYPE ASSERTION FAILED, file %s, line %u: %s\n", file, line, expr); - abort(); -#endif -} - -#if ET_DEBUG -#define ET_ASSERT(expr,file,line) \ -do { \ - if (!(expr)) \ - et_abort(#expr, file, line); \ -} while(0) -#else -#define ET_ASSERT(expr,file,line) do { } while(0) -#endif - -#if ET_DEBUG -unsigned tag_val_def_debug(Wterm x, const char *file, unsigned line) -#else -unsigned tag_val_def(Wterm x) -#define file __FILE__ -#define line __LINE__ -#endif -{ - static char msg[32]; - - switch (x & _TAG_PRIMARY_MASK) { - case TAG_PRIMARY_LIST: - ET_ASSERT(_list_precond(x),file,line); - return LIST_DEF; - case TAG_PRIMARY_BOXED: { - Eterm hdr = *boxed_val(x); - ET_ASSERT(is_header(hdr),file,line); - switch ((hdr & _TAG_HEADER_MASK) >> _TAG_PRIMARY_SIZE) { - case (_TAG_HEADER_ARITYVAL >> _TAG_PRIMARY_SIZE): return TUPLE_DEF; - case (_TAG_HEADER_POS_BIG >> _TAG_PRIMARY_SIZE): return BIG_DEF; - case (_TAG_HEADER_NEG_BIG >> _TAG_PRIMARY_SIZE): return BIG_DEF; - case (_TAG_HEADER_REF >> _TAG_PRIMARY_SIZE): return REF_DEF; - case (_TAG_HEADER_FLOAT >> _TAG_PRIMARY_SIZE): return FLOAT_DEF; - case (_TAG_HEADER_EXPORT >> _TAG_PRIMARY_SIZE): return EXPORT_DEF; - case (_TAG_HEADER_FUN >> _TAG_PRIMARY_SIZE): return FUN_DEF; - case (_TAG_HEADER_EXTERNAL_PID >> _TAG_PRIMARY_SIZE): return EXTERNAL_PID_DEF; - case (_TAG_HEADER_EXTERNAL_PORT >> _TAG_PRIMARY_SIZE): return EXTERNAL_PORT_DEF; - case (_TAG_HEADER_EXTERNAL_REF >> _TAG_PRIMARY_SIZE): return EXTERNAL_REF_DEF; - case (_TAG_HEADER_MAP >> _TAG_PRIMARY_SIZE): return MAP_DEF; - case (_TAG_HEADER_REFC_BIN >> _TAG_PRIMARY_SIZE): return BINARY_DEF; - case (_TAG_HEADER_HEAP_BIN >> _TAG_PRIMARY_SIZE): return BINARY_DEF; - case (_TAG_HEADER_SUB_BIN >> _TAG_PRIMARY_SIZE): return BINARY_DEF; - case (_TAG_HEADER_BIN_MATCHSTATE >> _TAG_PRIMARY_SIZE): return MATCHSTATE_DEF; - } - - break; - } - case TAG_PRIMARY_IMMED1: { - switch ((x & _TAG_IMMED1_MASK) >> _TAG_PRIMARY_SIZE) { - case (_TAG_IMMED1_PID >> _TAG_PRIMARY_SIZE): return PID_DEF; - case (_TAG_IMMED1_PORT >> _TAG_PRIMARY_SIZE): return PORT_DEF; - case (_TAG_IMMED1_IMMED2 >> _TAG_PRIMARY_SIZE): { - switch ((x & _TAG_IMMED2_MASK) >> _TAG_IMMED1_SIZE) { - case (_TAG_IMMED2_ATOM >> _TAG_IMMED1_SIZE): return ATOM_DEF; - case (_TAG_IMMED2_NIL >> _TAG_IMMED1_SIZE): return NIL_DEF; - } - break; - } - case (_TAG_IMMED1_SMALL >> _TAG_PRIMARY_SIZE): return SMALL_DEF; - } - break; - } - } - erts_snprintf(msg, sizeof(msg), "tag_val_def: %#lx", (unsigned long) x); - et_abort(msg, file, line); -#undef file -#undef line -} - /* * XXX: define NUMBER_CODE() here when new representation is used */ diff --git a/erts/emulator/beam/erl_term.h b/erts/emulator/beam/erl_term.h index 2b28762db5..0a71534790 100644 --- a/erts/emulator/beam/erl_term.h +++ b/erts/emulator/beam/erl_term.h @@ -1129,11 +1129,11 @@ _ET_DECLARE_CHECKED(Uint,loader_y_reg_index,Uint) #define FIRST_VACANT_TAG_DEF 0x12 #if ET_DEBUG -extern unsigned tag_val_def_debug(Wterm, const char*, unsigned); -#define tag_val_def(x) tag_val_def_debug((x),__FILE__,__LINE__) +ERTS_GLB_INLINE unsigned tag_val_def(Wterm, const char*, unsigned); #else -extern unsigned tag_val_def(Wterm); +ERTS_GLB_INLINE unsigned tag_val_def(Wterm); #endif + #define not_eq_tags(X,Y) (tag_val_def((X)) ^ tag_val_def((Y))) #define NUMBER_CODE(x,y) ((tag_val_def(x) << 5) | tag_val_def(y)) @@ -1152,5 +1152,80 @@ extern unsigned tag_val_def(Wterm); void erts_set_literal_tag(Eterm *term, Eterm *hp_start, Eterm hsz); +#if ET_DEBUG +#define ET_ASSERT(expr,file,line) \ +do { \ + if (!(expr)) \ + erl_assert_error("TYPE ASSERTION: " #expr, __FUNCTION__, file, line); \ +} while(0) +#else +#define ET_ASSERT(expr,file,line) do { } while(0) +#endif + +#if ERTS_GLB_INLINE_INCL_FUNC_DEF + +#if ET_DEBUG +ERTS_GLB_INLINE unsigned tag_val_def(Wterm x, const char *file, unsigned line) +#else +ERTS_GLB_INLINE unsigned tag_val_def(Wterm x) +#define file __FILE__ +#define line __LINE__ +#endif +{ + static char *msg = "tag_val_def error"; + + switch (x & _TAG_PRIMARY_MASK) { + case TAG_PRIMARY_LIST: + ET_ASSERT(_list_precond(x),file,line); + return LIST_DEF; + case TAG_PRIMARY_BOXED: { + Eterm hdr = *boxed_val(x); + ET_ASSERT(is_header(hdr),file,line); + switch ((hdr & _TAG_HEADER_MASK) >> _TAG_PRIMARY_SIZE) { + case (_TAG_HEADER_ARITYVAL >> _TAG_PRIMARY_SIZE): return TUPLE_DEF; + case (_TAG_HEADER_POS_BIG >> _TAG_PRIMARY_SIZE): return BIG_DEF; + case (_TAG_HEADER_NEG_BIG >> _TAG_PRIMARY_SIZE): return BIG_DEF; + case (_TAG_HEADER_REF >> _TAG_PRIMARY_SIZE): return REF_DEF; + case (_TAG_HEADER_FLOAT >> _TAG_PRIMARY_SIZE): return FLOAT_DEF; + case (_TAG_HEADER_EXPORT >> _TAG_PRIMARY_SIZE): return EXPORT_DEF; + case (_TAG_HEADER_FUN >> _TAG_PRIMARY_SIZE): return FUN_DEF; + case (_TAG_HEADER_EXTERNAL_PID >> _TAG_PRIMARY_SIZE): return EXTERNAL_PID_DEF; + case (_TAG_HEADER_EXTERNAL_PORT >> _TAG_PRIMARY_SIZE): return EXTERNAL_PORT_DEF; + case (_TAG_HEADER_EXTERNAL_REF >> _TAG_PRIMARY_SIZE): return EXTERNAL_REF_DEF; + case (_TAG_HEADER_MAP >> _TAG_PRIMARY_SIZE): return MAP_DEF; + case (_TAG_HEADER_REFC_BIN >> _TAG_PRIMARY_SIZE): return BINARY_DEF; + case (_TAG_HEADER_HEAP_BIN >> _TAG_PRIMARY_SIZE): return BINARY_DEF; + case (_TAG_HEADER_SUB_BIN >> _TAG_PRIMARY_SIZE): return BINARY_DEF; + case (_TAG_HEADER_BIN_MATCHSTATE >> _TAG_PRIMARY_SIZE): return MATCHSTATE_DEF; + } + + break; + } + case TAG_PRIMARY_IMMED1: { + switch ((x & _TAG_IMMED1_MASK) >> _TAG_PRIMARY_SIZE) { + case (_TAG_IMMED1_PID >> _TAG_PRIMARY_SIZE): return PID_DEF; + case (_TAG_IMMED1_PORT >> _TAG_PRIMARY_SIZE): return PORT_DEF; + case (_TAG_IMMED1_IMMED2 >> _TAG_PRIMARY_SIZE): { + switch ((x & _TAG_IMMED2_MASK) >> _TAG_IMMED1_SIZE) { + case (_TAG_IMMED2_ATOM >> _TAG_IMMED1_SIZE): return ATOM_DEF; + case (_TAG_IMMED2_NIL >> _TAG_IMMED1_SIZE): return NIL_DEF; + } + break; + } + case (_TAG_IMMED1_SMALL >> _TAG_PRIMARY_SIZE): return SMALL_DEF; + } + break; + } + } + erl_assert_error(msg, __FUNCTION__, file, line); +#undef file +#undef line +} +#endif + +#if ET_DEBUG +#define tag_val_def(X) tag_val_def(X, __FILE__, __LINE__) +#endif + #endif /* __ERL_TERM_H */ diff --git a/erts/emulator/beam/erl_trace.c b/erts/emulator/beam/erl_trace.c index 41876b8c62..9033c1b75c 100644 --- a/erts/emulator/beam/erl_trace.c +++ b/erts/emulator/beam/erl_trace.c @@ -176,7 +176,7 @@ take_timestamp(ErtsTraceTimeStamp *tsp, int ts_type) hsz += 3; /* 2-tuple */ raw_unique = erts_raw_get_unique_monotonic_integer(); tsp->u.monotonic.raw_unique = raw_unique; - hsz += erts_raw_unique_monotonic_integer_heap_size(raw_unique); + hsz += erts_raw_unique_monotonic_integer_heap_size(raw_unique, 0); } return hsz; } @@ -216,8 +216,7 @@ write_timestamp(ErtsTraceTimeStamp *tsp, Eterm **hpp) return emtime; raw = tsp->u.monotonic.raw_unique; - unique = erts_raw_make_unique_monotonic_integer_value(hpp, - raw); + unique = erts_raw_make_unique_monotonic_integer_value(hpp, raw, 0); res = TUPLE2(*hpp, emtime, unique); *hpp += 3; return res; diff --git a/erts/emulator/beam/external.c b/erts/emulator/beam/external.c index aac1490f0c..10f03636ec 100644 --- a/erts/emulator/beam/external.c +++ b/erts/emulator/beam/external.c @@ -967,19 +967,24 @@ erts_decode_dist_ext(ErtsHeapFactory* factory, return THE_NON_VALUE; } -Eterm erts_decode_ext(ErtsHeapFactory* factory, byte **ext) +Eterm erts_decode_ext(ErtsHeapFactory* factory, byte **ext, Uint32 flags) { + ErtsDistExternal ede, *edep; Eterm obj; byte *ep = *ext; if (*ep++ != VERSION_MAGIC) { erts_factory_undo(factory); return THE_NON_VALUE; } - ep = dec_term(NULL, factory, ep, &obj, NULL); + if (flags) { + ASSERT(flags == ERTS_DIST_EXT_BTT_SAFE); + ede.flags = flags; /* a dummy struct just for the flags */ + edep = &ede; + } else { + edep = NULL; + } + ep = dec_term(edep, factory, ep, &obj, NULL); if (!ep) { -#ifdef DEBUG - bin_write(ERTS_PRINT_STDERR,NULL,*ext,500); -#endif return THE_NON_VALUE; } *ext = ep; diff --git a/erts/emulator/beam/external.h b/erts/emulator/beam/external.h index d12051c6b4..87eff2fe9f 100644 --- a/erts/emulator/beam/external.h +++ b/erts/emulator/beam/external.h @@ -191,7 +191,7 @@ Eterm erts_decode_dist_ext(ErtsHeapFactory* factory, ErtsDistExternal *); Sint erts_decode_ext_size(byte*, Uint); Sint erts_decode_ext_size_ets(byte*, Uint); -Eterm erts_decode_ext(ErtsHeapFactory*, byte**); +Eterm erts_decode_ext(ErtsHeapFactory*, byte**, Uint32 flags); Eterm erts_decode_ext_ets(ErtsHeapFactory*, byte*); Eterm erts_term_to_binary(Process* p, Eterm Term, int level, Uint flags); diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c index 797e4cdadc..29f28cc9dc 100644 --- a/erts/emulator/beam/io.c +++ b/erts/emulator/beam/io.c @@ -397,7 +397,7 @@ static Port *create_port(char *name, prt->common.u.alive.reg = NULL; ERTS_PTMR_INIT(prt); erts_port_task_handle_init(&prt->timeout_task); - prt->psd = NULL; + erts_smp_atomic_init_nob(&prt->psd, (erts_aint_t) NULL); prt->async_open_port = NULL; prt->drv_data = (SWord) 0; prt->os_pid = -1; @@ -1542,8 +1542,19 @@ erts_schedule_proc2port_signal(Process *c_p, erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN); if (sched_res != 0) { - if (refp) + if (refp) { + /* + * We need to restore the message queue save + * pointer to the beginning of the message queue + * since the caller now wont wait for a message + * containing the reference created above... + */ + ASSERT(c_p); + erts_smp_proc_lock(c_p, ERTS_PROC_LOCKS_MSG_RECEIVE); + JOIN_MESSAGE(c_p); + erts_smp_proc_unlock(c_p, ERTS_PROC_LOCKS_MSG_RECEIVE); *refp = NIL; + } return ERTS_PORT_OP_DROPPED; } return ERTS_PORT_OP_SCHEDULED; @@ -1749,7 +1760,6 @@ cleanup_scheduled_outputv(ErlIOVec *ev, ErlDrvBinary *cbinp) driver_free_binary(ev->binv[i]); if (cbinp) driver_free_binary(cbinp); - erts_free(ERTS_ALC_T_DRV_CMD_DATA, ev); } static int @@ -1887,6 +1897,188 @@ port_sig_output(Port *prt, erts_aint32_t state, int op, ErtsProc2PortSigData *si return ERTS_PORT_REDS_CMD_OUTPUT; } + +/* + * This erts_port_output will always create a port task. + * The call is treated as a port_command call, i.e. no + * badsig i generated if the input in invalid. However + * an error_logger message is generated. + */ +int +erts_port_output_async(Port *prt, Eterm from, Eterm list) +{ + + ErtsPortOpResult res; + ErtsProc2PortSigData *sigdp; + erts_driver_t *drv = prt->drv_ptr; + size_t size; + int task_flags; + ErtsProc2PortSigCallback port_sig_callback; + ErlDrvBinary *cbin = NULL; + ErlIOVec *evp = NULL; + char *buf = NULL; + ErtsPortTaskHandle *ns_pthp; + + if (drv->outputv) { + ErlIOVec ev; + SysIOVec* ivp; + ErlDrvBinary** bvp; + int vsize; + Uint csize; + Uint pvsize; + Uint pcsize; + size_t iov_offset, binv_offset, alloc_size; + Uint blimit = 0; + char *ptr; + int i; + + Eterm* bptr = NULL; + Uint offset; + + if (is_binary(list)) { + /* We optimize for when we get a procbin without offset */ + Eterm real_bin; + int bitoffs; + int bitsize; + ERTS_GET_REAL_BIN(list, real_bin, offset, bitoffs, bitsize); + bptr = binary_val(real_bin); + if (*bptr == HEADER_PROC_BIN && bitoffs == 0) { + size = binary_size(list); + vsize = 1; + } else + bptr = NULL; + } + + if (!bptr) { + if (io_list_vec_len(list, &vsize, &csize, &pvsize, &pcsize, &size)) + goto bad_value; + + /* To pack or not to pack (small binaries) ...? */ + if (vsize >= SMALL_WRITE_VEC) { + /* Do pack */ + vsize = pvsize + 1; + csize = pcsize; + blimit = ERL_SMALL_IO_BIN_LIMIT; + } + cbin = driver_alloc_binary(csize); + if (!cbin) + erts_alloc_enomem(ERTS_ALC_T_DRV_BINARY, ERTS_SIZEOF_Binary(csize)); + } + + + iov_offset = ERTS_ALC_DATA_ALIGN_SIZE(sizeof(ErlIOVec)); + binv_offset = iov_offset; + binv_offset += ERTS_ALC_DATA_ALIGN_SIZE((vsize+1)*sizeof(SysIOVec)); + alloc_size = binv_offset; + alloc_size += (vsize+1)*sizeof(ErlDrvBinary *); + + sigdp = erts_port_task_alloc_p2p_sig_data_extra(alloc_size, (void**)&ptr); + + evp = (ErlIOVec *) ptr; + ivp = evp->iov = (SysIOVec *) (ptr + iov_offset); + bvp = evp->binv = (ErlDrvBinary **) (ptr + binv_offset); + + ivp[0].iov_base = NULL; + ivp[0].iov_len = 0; + bvp[0] = NULL; + + if (bptr) { + ProcBin* pb = (ProcBin *) bptr; + + ivp[1].iov_base = pb->bytes+offset; + ivp[1].iov_len = size; + bvp[1] = Binary2ErlDrvBinary(pb->val); + + evp->vsize = 1; + } else { + + evp->vsize = io_list_to_vec(list, ivp+1, bvp+1, cbin, blimit); + if (evp->vsize < 0) { + if (evp != &ev) + erts_free(ERTS_ALC_T_DRV_CMD_DATA, evp); + driver_free_binary(cbin); + goto bad_value; + } + } +#if 0 + /* This assertion may say something useful, but it can + be falsified during the emulator test suites. */ + ASSERT(evp->vsize == vsize); +#endif + evp->vsize++; + evp->size = size; /* total size */ + + /* Need to increase refc on all binaries */ + for (i = 1; i < evp->vsize; i++) + if (bvp[i]) + driver_binary_inc_refc(bvp[i]); + + sigdp->flags = ERTS_P2P_SIG_TYPE_OUTPUTV; + sigdp->u.outputv.from = from; + sigdp->u.outputv.evp = evp; + sigdp->u.outputv.cbinp = cbin; + port_sig_callback = port_sig_outputv; + } else { + ErlDrvSizeT ERTS_DECLARE_DUMMY(r); + + /* + * Apperently there exist code that write 1 byte to + * much in buffer. Where it resides I don't know, but + * we can live with one byte extra allocated... + */ + + if (erts_iolist_size(list, &size)) + goto bad_value; + + buf = erts_alloc(ERTS_ALC_T_DRV_CMD_DATA, size + 1); + + r = erts_iolist_to_buf(list, buf, size); + ASSERT(ERTS_IOLIST_TO_BUF_SUCCEEDED(r)); + + sigdp = erts_port_task_alloc_p2p_sig_data(); + sigdp->flags = ERTS_P2P_SIG_TYPE_OUTPUT; + sigdp->u.output.from = from; + sigdp->u.output.bufp = buf; + sigdp->u.output.size = size; + port_sig_callback = port_sig_output; + } + sigdp->flags = 0; + ns_pthp = NULL; + task_flags = 0; + + res = erts_schedule_proc2port_signal(NULL, + prt, + ERTS_INVALID_PID, + NULL, + sigdp, + task_flags, + ns_pthp, + port_sig_callback); + + if (res != ERTS_PORT_OP_SCHEDULED) { + if (drv->outputv) + cleanup_scheduled_outputv(evp, cbin); + else + cleanup_scheduled_output(buf); + return 1; + } + return 1; + +bad_value: + + /* + * We call badsig directly here as this function is called with + * the main lock of the calling process still held. + * At the moment this operation is always not a bang_op, so + * only an error_logger message should be generated, no badsig. + */ + + badsig_received(0, prt, erts_atomic32_read_nob(&prt->state), 1); + + return 0; + +} + ErtsPortOpResult erts_port_output(Process *c_p, int flags, @@ -1896,7 +2088,7 @@ erts_port_output(Process *c_p, Eterm *refp) { ErtsPortOpResult res; - ErtsProc2PortSigData *sigdp; + ErtsProc2PortSigData *sigdp = NULL; erts_driver_t *drv = prt->drv_ptr; size_t size; int try_call; @@ -1978,10 +2170,13 @@ erts_port_output(Process *c_p, evp = &ev; } else { - char *ptr = erts_alloc((try_call - ? ERTS_ALC_T_TMP - : ERTS_ALC_T_DRV_CMD_DATA), alloc_size); - + char *ptr; + if (try_call) { + ptr = erts_alloc(ERTS_ALC_T_TMP, alloc_size); + } else { + sigdp = erts_port_task_alloc_p2p_sig_data_extra( + alloc_size, (void**)&ptr); + } evp = (ErlIOVec *) ptr; ivp = evp->iov = (SysIOVec *) (ptr + iov_offset); bvp = evp->binv = (ErlDrvBinary **) (ptr + binv_offset); @@ -2010,9 +2205,12 @@ erts_port_output(Process *c_p, bvp[0] = NULL; evp->vsize = io_list_to_vec(list, ivp+1, bvp+1, cbin, blimit); if (evp->vsize < 0) { - if (evp != &ev) - erts_free(try_call ? ERTS_ALC_T_TMP : ERTS_ALC_T_DRV_CMD_DATA, - evp); + if (evp != &ev) { + if (try_call) + erts_free(ERTS_ALC_T_TMP, evp); + else + erts_port_task_free_p2p_sig_data(sigdp); + } driver_free_binary(cbin); goto bad_value; } @@ -2064,8 +2262,10 @@ erts_port_output(Process *c_p, /* Fall through... */ case ERTS_TRY_IMM_DRV_CALL_INVALID_PORT: driver_free_binary(cbin); - if (evp != &ev) + if (evp != &ev) { + ASSERT(!sigdp); erts_free(ERTS_ALC_T_TMP, evp); + } if (try_call_res != ERTS_TRY_IMM_DRV_CALL_OK) return ERTS_PORT_OP_DROPPED; if (c_p) @@ -2076,8 +2276,10 @@ erts_port_output(Process *c_p, if (async_nosuspend && (sched_flags & (busy_flgs|ERTS_PTS_FLG_EXIT))) { driver_free_binary(cbin); - if (evp != &ev) + if (evp != &ev) { + ASSERT(!sigdp); erts_free(ERTS_ALC_T_TMP, evp); + } return ((sched_flags & ERTS_PTS_FLG_EXIT) ? ERTS_PORT_OP_DROPPED : ERTS_PORT_OP_BUSY); @@ -2092,9 +2294,16 @@ erts_port_output(Process *c_p, if (bvp[i]) driver_binary_inc_refc(bvp[i]); - new_evp = erts_alloc(ERTS_ALC_T_DRV_CMD_DATA, alloc_size); + /* The port task and iovec is allocated in the + same structure as an optimization. This + is especially important in erts_port_output_async + of when !try_call */ + ASSERT(sigdp == NULL); + sigdp = erts_port_task_alloc_p2p_sig_data_extra( + alloc_size, (void**)&new_evp); if (evp != &ev) { + /* Copy from TMP alloc to port task */ sys_memcpy((void *) new_evp, (void *) evp, alloc_size); new_evp->iov = (SysIOVec *) (((char *) new_evp) + iov_offset); @@ -2142,7 +2351,6 @@ erts_port_output(Process *c_p, evp = new_evp; } - sigdp = erts_port_task_alloc_p2p_sig_data(); sigdp->flags = ERTS_P2P_SIG_TYPE_OUTPUTV; sigdp->u.outputv.from = from; sigdp->u.outputv.evp = evp; @@ -3520,6 +3728,7 @@ terminate_port(Port *prt) Eterm connected_id = NIL /* Initialize to silence compiler */; erts_driver_t *drv; erts_aint32_t state; + ErtsPrtSD *psd; ERTS_SMP_CHK_NO_PROC_LOCKS; ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt)); @@ -3573,8 +3782,9 @@ terminate_port(Port *prt) erts_cleanup_port_data(prt); - if (prt->psd) - erts_free(ERTS_ALC_T_PRTSD, prt->psd); + psd = (ErtsPrtSD *) erts_smp_atomic_read_nob(&prt->psd); + if (psd) + erts_free(ERTS_ALC_T_PRTSD, psd); ASSERT(prt->dist_entry == NULL); @@ -4373,7 +4583,7 @@ port_sig_call(Port *prt, (void) erts_factory_message_create(&factory, rp, &rp_locks, hsz); endp = (byte *) resp_bufp; - msg = erts_decode_ext(&factory, &endp); + msg = erts_decode_ext(&factory, &endp, 0); if (is_value(msg)) { hp = erts_produce_heap(&factory, 3, @@ -4492,7 +4702,7 @@ erts_port_call(Process* c_p, hsz += 3; erts_factory_proc_prealloc_init(&factory, c_p, hsz); endp = (byte *) resp_bufp; - term = erts_decode_ext(&factory, &endp); + term = erts_decode_ext(&factory, &endp, 0); if (term == THE_NON_VALUE) return ERTS_PORT_OP_BADARG; hp = erts_produce_heap(&factory,3,0); diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h index 03b9088adc..44735c0ec0 100644 --- a/erts/emulator/beam/sys.h +++ b/erts/emulator/beam/sys.h @@ -138,10 +138,10 @@ typedef ERTS_SYS_FD_TYPE ErtsSysFdType; #endif #if ERTS_AT_LEAST_GCC_VSN__(2, 96, 0) -#ifndef __llvm__ -# define ERTS_WRITE_UNLIKELY(X) X __attribute__ ((section ("ERTS_LOW_WRITE") )) -#else +#if (defined(__APPLE__) && defined(__MACH__)) || defined(__DARWIN__) # define ERTS_WRITE_UNLIKELY(X) X __attribute__ ((section ("__DATA,ERTS_LOW_WRITE") )) +#else +# define ERTS_WRITE_UNLIKELY(X) X __attribute__ ((section ("ERTS_LOW_WRITE") )) #endif #else # define ERTS_WRITE_UNLIKELY(X) X diff --git a/erts/emulator/sys/win32/sys.c b/erts/emulator/sys/win32/sys.c index ea7523ddc2..391bbd4cbc 100644 --- a/erts/emulator/sys/win32/sys.c +++ b/erts/emulator/sys/win32/sys.c @@ -3079,6 +3079,8 @@ erl_bin_write(buf, sz, max) } } +#endif /* DEBUG */ + void erl_assert_error(const char* expr, const char* func, const char* file, int line) { @@ -3094,7 +3096,6 @@ erl_assert_error(const char* expr, const char* func, const char* file, int line) DebugBreak(); } -#endif /* DEBUG */ static void check_supported_os_version(void) diff --git a/erts/emulator/test/nif_SUITE.erl b/erts/emulator/test/nif_SUITE.erl index 84f5699890..a185b72341 100644 --- a/erts/emulator/test/nif_SUITE.erl +++ b/erts/emulator/test/nif_SUITE.erl @@ -42,7 +42,12 @@ dirty_nif_exception/1, call_dirty_nif_exception/1, nif_schedule/1, nif_exception/1, call_nif_exception/1, nif_nan_and_inf/1, nif_atom_too_long/1, - nif_monotonic_time/1, nif_time_offset/1, nif_convert_time_unit/1]). + nif_monotonic_time/1, nif_time_offset/1, nif_convert_time_unit/1, + nif_now_time/1, nif_cpu_time/1, nif_unique_integer/1, + nif_is_process_alive/1, nif_is_port_alive/1, + nif_term_to_binary/1, nif_binary_to_term/1, + nif_port_command/1 + ]). -export([many_args_100/100]). @@ -72,7 +77,11 @@ all() -> otp_9668, consume_timeslice, nif_schedule, dirty_nif, dirty_nif_send, dirty_nif_exception, nif_exception, nif_nan_and_inf, nif_atom_too_long, - nif_monotonic_time, nif_time_offset, nif_convert_time_unit + nif_monotonic_time, nif_time_offset, nif_convert_time_unit, + nif_now_time, nif_cpu_time, nif_unique_integer, + nif_is_process_alive, nif_is_port_alive, + nif_term_to_binary, nif_binary_to_term, + nif_port_command ]. init_per_testcase(_Case, Config) -> @@ -1365,14 +1374,16 @@ get_length(Config) when is_list(Config) -> ensure_lib_loaded(Config) -> ensure_lib_loaded(Config, 1). ensure_lib_loaded(Config, Ver) -> + Path = ?config(data_dir, Config), case lib_version() of - undefined -> - Path = proplists:get_value(data_dir, Config), - Lib = "nif_SUITE." ++ integer_to_list(Ver), - ok = erlang:load_nif(filename:join(Path,Lib), []); - Ver when is_integer(Ver) -> - ok - end. + undefined -> + Lib = "nif_SUITE." ++ integer_to_list(Ver), + ok = erlang:load_nif(filename:join(Path,Lib), []); + Ver when is_integer(Ver) -> + ok + end, + erl_ddll:try_load(Path, echo_drv, []), + ok. make_atom(Config) when is_list(Config) -> ensure_lib_loaded(Config, 1), @@ -1885,6 +1896,129 @@ chk_ctu(Time, FromTU, [ToTU|ToTUs]) -> chk_ctu(Time, FromTU, ToTUs) end. +nif_now_time(Config) -> + ensure_lib_loaded(Config), + + N1 = now(), + NifN1 = now_time(), + NifN2 = now_time(), + N2 = now(), + true = N1 < NifN1, + true = NifN1 < NifN2, + true = NifN2 < N2. + +nif_cpu_time(Config) -> + ensure_lib_loaded(Config), + + try cpu_time() of + {_, _, _} -> + ok + catch error:badarg -> + {comment, "cpu_time not supported"} + end. + +nif_unique_integer(Config) -> + ensure_lib_loaded(Config), + + UM1 = erlang:unique_integer([monotonic]), + UM2 = unique_integer_nif([monotonic]), + UM3 = erlang:unique_integer([monotonic]), + + true = UM1 < UM2, + true = UM2 < UM3, + + UMP1 = erlang:unique_integer([monotonic, positive]), + UMP2 = unique_integer_nif([monotonic, positive]), + UMP3 = erlang:unique_integer([monotonic, positive]), + + true = 0 =< UMP1, + true = UMP1 < UMP2, + true = UMP2 < UMP3, + + UP1 = erlang:unique_integer([positive]), + UP2 = unique_integer_nif([positive]), + UP3 = erlang:unique_integer([positive]), + + true = 0 =< UP1, + true = 0 =< UP2, + true = 0 =< UP3, + + true = is_integer(unique_integer_nif([])), + true = is_integer(unique_integer_nif([])), + true = is_integer(unique_integer_nif([])). + +nif_is_process_alive(Config) -> + ensure_lib_loaded(Config), + + {Pid,_} = spawn_monitor(fun() -> receive ok -> nok end end), + true = is_process_alive_nif(Pid), + exit(Pid, die), + receive _ -> ok end, %% Clear monitor + false = is_process_alive_nif(Pid). + +nif_is_port_alive(Config) -> + ensure_lib_loaded(Config), + + Port = open_port({spawn,echo_drv},[eof]), + true = is_port_alive_nif(Port), + port_close(Port), + false = is_port_alive_nif(Port). + +nif_term_to_binary(Config) -> + ensure_lib_loaded(Config), + T = {#{ok => nok}, <<0:8096>>, lists:seq(1,100)}, + Bin = term_to_binary(T), + ct:log("~p",[Bin]), + Bin = term_to_binary_nif(T, undefined), + true = term_to_binary_nif(T, self()), + receive Bin -> ok end. + +-define(ERL_NIF_BIN2TERM_SAFE, 16#20000000). + +nif_binary_to_term(Config) -> + ensure_lib_loaded(Config), + T = {#{ok => nok}, <<0:8096>>, lists:seq(1,100)}, + Bin = term_to_binary(T), + Len = byte_size(Bin), + {Len,T} = binary_to_term_nif(Bin, undefined, 0), + Len = binary_to_term_nif(Bin, self(), 0), + T = receive M -> M after 1000 -> timeout end, + + {Len, T} = binary_to_term_nif(Bin, undefined, ?ERL_NIF_BIN2TERM_SAFE), + false = binary_to_term_nif(<<131,100,0,14,"undefined_atom">>, + undefined, ?ERL_NIF_BIN2TERM_SAFE), + false = binary_to_term_nif(Bin, undefined, 1), + ok. + +nif_port_command(Config) -> + ensure_lib_loaded(Config), + + Port = open_port({spawn,echo_drv},[eof]), + true = port_command_nif(Port, "hello\n"), + receive {Port,{data,"hello\n"}} -> ok + after 1000 -> ct:fail(timeout) end, + + RefcBin = lists:flatten([lists:duplicate(100, "hello"),"\n"]), + true = port_command_nif(Port, iolist_to_binary(RefcBin)), + receive {Port,{data,RefcBin}} -> ok + after 1000 -> ct:fail(timeout) end, + + %% Test that invalid arguments correctly returns + %% badarg and that the port survives. + {'EXIT', {badarg, _}} = (catch port_command_nif(Port, [ok])), + + IoList = [lists:duplicate(100,<<"hello">>),"\n"], + true = port_command_nif(Port, [IoList]), + FlatIoList = binary_to_list(iolist_to_binary(IoList)), + receive {Port,{data,FlatIoList}} -> ok + after 1000 -> ct:fail(timeout) end, + + port_close(Port), + + {'EXIT', {badarg, _}} = (catch port_command_nif(Port, "hello\n")), + + ok. + %% The NIFs: lib_version() -> undefined. call_history() -> ?nif_stub. @@ -1942,6 +2076,12 @@ call_dirty_nif_zero_args() -> ?nif_stub. call_nif_exception(_) -> ?nif_stub. call_nif_nan_or_inf(_) -> ?nif_stub. call_nif_atom_too_long(_) -> ?nif_stub. +unique_integer_nif(_) -> ?nif_stub. +is_process_alive_nif(_) -> ?nif_stub. +is_port_alive_nif(_) -> ?nif_stub. +term_to_binary_nif(_, _) -> ?nif_stub. +binary_to_term_nif(_, _, _) -> ?nif_stub. +port_command_nif(_, _) -> ?nif_stub. %% maps is_map_nif(_) -> ?nif_stub. @@ -1958,7 +2098,8 @@ sorted_list_from_maps_nif(_) -> ?nif_stub. monotonic_time(_) -> ?nif_stub. time_offset(_) -> ?nif_stub. convert_time_unit(_,_,_) -> ?nif_stub. - +now_time() -> ?nif_stub. +cpu_time() -> ?nif_stub. nif_stub_error(Line) -> exit({nif_not_loaded,module,?MODULE,line,Line}). diff --git a/erts/emulator/test/nif_SUITE_data/Makefile.src b/erts/emulator/test/nif_SUITE_data/Makefile.src index ab4ff77add..fbb8978771 100644 --- a/erts/emulator/test/nif_SUITE_data/Makefile.src +++ b/erts/emulator/test/nif_SUITE_data/Makefile.src @@ -4,8 +4,7 @@ NIF_LIBS = nif_SUITE.1@dll@ \ nif_mod.2@dll@ \ nif_mod.3@dll@ -all: $(NIF_LIBS) basic@dll@ rwlock@dll@ tsd@dll@ - +all: $(NIF_LIBS) basic@dll@ rwlock@dll@ tsd@dll@ echo_drv@dll@ @SHLIB_RULES@ diff --git a/erts/emulator/test/nif_SUITE_data/echo_drv.c b/erts/emulator/test/nif_SUITE_data/echo_drv.c new file mode 100644 index 0000000000..2b3510c641 --- /dev/null +++ b/erts/emulator/test/nif_SUITE_data/echo_drv.c @@ -0,0 +1,62 @@ +#include <stdio.h> +#include "erl_driver.h" + +static ErlDrvPort erlang_port; +static ErlDrvData echo_start(ErlDrvPort, char *); +static void from_erlang(ErlDrvData, char*, ErlDrvSizeT); +static ErlDrvSSizeT echo_call(ErlDrvData drv_data, unsigned int command, + char *buf, ErlDrvSizeT len, + char **rbuf, ErlDrvSizeT rlen, unsigned *ret_flags); +static ErlDrvEntry echo_driver_entry = { + NULL, /* Init */ + echo_start, + NULL, /* Stop */ + from_erlang, + NULL, /* Ready input */ + NULL, /* Ready output */ + "echo_drv", + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + echo_call, + NULL, + ERL_DRV_EXTENDED_MARKER, + ERL_DRV_EXTENDED_MAJOR_VERSION, + ERL_DRV_EXTENDED_MINOR_VERSION, + 0, + NULL, + NULL, + NULL +}; + +DRIVER_INIT(echo_drv) +{ + return &echo_driver_entry; +} + +static ErlDrvData +echo_start(ErlDrvPort port, char *buf) +{ + return (ErlDrvData) port; +} + +static void +from_erlang(ErlDrvData data, char *buf, ErlDrvSizeT count) +{ + driver_output((ErlDrvPort) data, buf, count); +} + +static ErlDrvSSizeT +echo_call(ErlDrvData drv_data, unsigned int command, + char *buf, ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen, + unsigned *ret_flags) +{ + *rbuf = buf; + *ret_flags |= DRIVER_CALL_KEEP_BUFFER; + return len; +} + diff --git a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c index 1acb270d1f..b3c6cc5ba3 100644 --- a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c +++ b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c @@ -30,6 +30,7 @@ static int static_cntA; /* zero by default */ static int static_cntB = NIF_SUITE_LIB_VER * 100; static ERL_NIF_TERM atom_false; +static ERL_NIF_TERM atom_true; static ERL_NIF_TERM atom_self; static ERL_NIF_TERM atom_ok; static ERL_NIF_TERM atom_join; @@ -138,6 +139,7 @@ static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) msgenv_dtor, ERL_NIF_RT_CREATE, NULL); atom_false = enif_make_atom(env,"false"); + atom_true = enif_make_atom(env,"true"); atom_self = enif_make_atom(env,"self"); atom_ok = enif_make_atom(env,"ok"); atom_join = enif_make_atom(env,"join"); @@ -1978,6 +1980,123 @@ static ERL_NIF_TERM convert_time_unit(ErlNifEnv* env, int argc, const ERL_NIF_TE return enif_make_int64(env, enif_convert_time_unit(val, from, to)); } +static ERL_NIF_TERM now_time(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + return enif_now_time(env); +} + +static ERL_NIF_TERM cpu_time(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + return enif_cpu_time(env); +} + +static ERL_NIF_TERM unique_integer(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + ERL_NIF_TERM atom_pos = enif_make_atom(env,"positive"), + atom_mon = enif_make_atom(env,"monotonic"); + ERL_NIF_TERM opts = argv[0], opt; + ErlNifUniqueInteger properties = 0; + + while (!enif_is_empty_list(env, opts)) { + if (!enif_get_list_cell(env, opts, &opt, &opts)) + return enif_make_badarg(env); + + if (enif_compare(opt, atom_pos) == 0) + properties |= ERL_NIF_UNIQUE_POSITIVE; + if (enif_compare(opt, atom_mon) == 0) + properties |= ERL_NIF_UNIQUE_MONOTONIC; + } + + return enif_make_unique_integer(env, properties); +} + +static ERL_NIF_TERM is_process_alive(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + ErlNifPid pid; + if (!enif_get_local_pid(env, argv[0], &pid)) + return enif_make_badarg(env); + if (enif_is_process_alive(env, &pid)) + return atom_true; + return atom_false; +} + +static ERL_NIF_TERM is_port_alive(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + ErlNifPort port; + if (!enif_get_local_port(env, argv[0], &port)) + return enif_make_badarg(env); + if (enif_is_port_alive(env, &port)) + return atom_true; + return atom_false; +} + +static ERL_NIF_TERM term_to_binary(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + ErlNifBinary bin; + ErlNifPid pid; + ErlNifEnv *msg_env = env; + ERL_NIF_TERM term; + + if (enif_get_local_pid(env, argv[1], &pid)) + msg_env = enif_alloc_env(); + + if (!enif_term_to_binary(msg_env, argv[0], &bin)) + return enif_make_badarg(env); + + term = enif_make_binary(msg_env, &bin); + + if (msg_env != env) { + enif_send(env, &pid, msg_env, term); + enif_free_env(msg_env); + return atom_true; + } else { + return term; + } +} + +static ERL_NIF_TERM binary_to_term(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + ErlNifBinary bin; + ERL_NIF_TERM term, ret_term; + ErlNifPid pid; + ErlNifEnv *msg_env = env; + unsigned int opts; + ErlNifUInt64 ret; + + if (enif_get_local_pid(env, argv[1], &pid)) + msg_env = enif_alloc_env(); + + if (!enif_inspect_binary(env, argv[0], &bin) + || !enif_get_uint(env, argv[2], &opts)) + return enif_make_badarg(env); + + ret = enif_binary_to_term(msg_env, bin.data, bin.size, &term, + (ErlNifBinaryToTerm)opts); + if (!ret) + return atom_false; + + ret_term = enif_make_uint64(env, ret); + if (msg_env != env) { + enif_send(env, &pid, msg_env, term); + enif_free_env(msg_env); + return ret_term; + } else { + return enif_make_tuple2(env, ret_term, term); + } +} + +static ERL_NIF_TERM port_command(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + ErlNifPort port; + + if (!enif_get_local_port(env, argv[0], &port)) + return enif_make_badarg(env); + + if (!enif_port_command(env, &port, NULL, argv[1])) + return enif_make_badarg(env); + return atom_true; +} + static ErlNifFunc nif_funcs[] = { {"lib_version", 0, lib_version}, @@ -2050,8 +2169,15 @@ static ErlNifFunc nif_funcs[] = {"sorted_list_from_maps_nif", 1, sorted_list_from_maps_nif}, {"monotonic_time", 1, monotonic_time}, {"time_offset", 1, time_offset}, - {"convert_time_unit", 3, convert_time_unit} + {"convert_time_unit", 3, convert_time_unit}, + {"now_time", 0, now_time}, + {"cpu_time", 0, cpu_time}, + {"unique_integer_nif", 1, unique_integer}, + {"is_process_alive_nif", 1, is_process_alive}, + {"is_port_alive_nif", 1, is_port_alive}, + {"term_to_binary_nif", 2, term_to_binary}, + {"binary_to_term_nif", 3, binary_to_term}, + {"port_command_nif", 2, port_command} }; ERL_NIF_INIT(nif_SUITE,nif_funcs,load,reload,upgrade,unload) - diff --git a/erts/include/internal/ethread.h b/erts/include/internal/ethread.h index e5c5cdfa33..b23644d361 100644 --- a/erts/include/internal/ethread.h +++ b/erts/include/internal/ethread.h @@ -112,6 +112,10 @@ int ethr_assert_failed(const char *file, int line, const char *func, char *a); #error "_GNU_SOURCE not defined. Please, compile all files with -D_GNU_SOURCE." #endif +#ifdef ETHR_HAVE_PTHREAD_SETNAME_NP_1 +#define _DARWIN_C_SOURCE +#endif + #if defined(ETHR_NEED_NPTL_PTHREAD_H) #include <nptl/pthread.h> #elif defined(ETHR_HAVE_MIT_PTHREAD_H) diff --git a/erts/preloaded/ebin/erl_prim_loader.beam b/erts/preloaded/ebin/erl_prim_loader.beam Binary files differindex 6d777fa811..f224178c4f 100644 --- a/erts/preloaded/ebin/erl_prim_loader.beam +++ b/erts/preloaded/ebin/erl_prim_loader.beam diff --git a/erts/preloaded/ebin/init.beam b/erts/preloaded/ebin/init.beam Binary files differindex 9d2dd38f3a..7d73ca2234 100644 --- a/erts/preloaded/ebin/init.beam +++ b/erts/preloaded/ebin/init.beam diff --git a/erts/preloaded/src/erl_prim_loader.erl b/erts/preloaded/src/erl_prim_loader.erl index cbcced5512..641abae7b1 100644 --- a/erts/preloaded/src/erl_prim_loader.erl +++ b/erts/preloaded/src/erl_prim_loader.erl @@ -56,7 +56,7 @@ -export([purge_archive_cache/0]). %% Used by init and the code server. --export([get_modules/3]). +-export([get_modules/2,get_modules/3]). -include_lib("kernel/include/file.hrl"). @@ -239,6 +239,13 @@ set_primary_archive(File, ArchiveBin, FileInfo, ParserFun) purge_archive_cache() -> request(purge_archive_cache). +-spec get_modules([module()], + fun((atom(), string(), binary()) -> + {'ok',any()} | {'error',any()})) -> + {'ok',{[any()],[any()]}}. + +get_modules(Modules, Fun) -> + request({get_modules,{Modules,Fun}}). -spec get_modules([module()], fun((atom(), string(), binary()) -> @@ -338,6 +345,8 @@ handle_request(Req, Paths, St0) -> {{ok,Paths},St0}; {get_file,File} -> handle_get_file(St0, Paths, File); + {get_modules,{Modules,Fun}} -> + handle_get_modules(St0, Modules, Fun, Paths); {get_modules,{Modules,Fun,ModPaths}} -> handle_get_modules(St0, Modules, Fun, ModPaths); {list_dir,Dir} -> diff --git a/erts/preloaded/src/init.erl b/erts/preloaded/src/init.erl index 5de3732c20..915f1183d6 100644 --- a/erts/preloaded/src/init.erl +++ b/erts/preloaded/src/init.erl @@ -297,9 +297,9 @@ crash(String, List) -> -spec boot_loop(pid(), state()) -> no_return(). boot_loop(BootPid, State) -> receive - {BootPid,loaded,ModLoaded} -> - Loaded = State#state.loaded, - boot_loop(BootPid,State#state{loaded = [ModLoaded|Loaded]}); + {BootPid,loaded,NewlyLoaded} -> + Loaded = NewlyLoaded ++ State#state.loaded, + boot_loop(BootPid, State#state{loaded = Loaded}); {BootPid,started,KernelPid} -> boot_loop(BootPid, new_kernelpid(KernelPid, BootPid, State)); {BootPid,progress,started} -> @@ -338,12 +338,25 @@ boot_loop(BootPid, State) -> end. ensure_loaded(Module, Loaded) -> + case erlang:module_loaded(Module) of + true -> + {{module, Module}, Loaded}; + false -> + do_ensure_loaded(Module, Loaded) + end. + +do_ensure_loaded(Module, Loaded) -> File = atom_to_list(Module) ++ objfile_extension(), - case catch load_mod(Module,File) of - {ok, FullName} -> - {{module, Module}, [{Module, FullName}|Loaded]}; - Res -> - {Res, Loaded} + case erl_prim_loader:get_file(File) of + {ok,BinCode,FullName} -> + case do_load_module(Module, BinCode) of + ok -> + {{module, Module}, [{Module, FullName}|Loaded]}; + error -> + {error, [{Module, FullName}|Loaded]} + end; + Error -> + {Error, Loaded} end. %% Tell subscribed processes the system has started. @@ -842,13 +855,6 @@ eval_script([{kernel_load_completed}|T], #es{load_mode=Mode}=Es0) -> _ -> Es0#es{prim_load=false} end, eval_script(T, Es); -eval_script([{primLoad,[Mod]}|T], #es{prim_load=true}=Es) -> - %% Common special case (loading of error_handler). Nothing - %% to gain by parallel loading. - File = atom_to_list(Mod) ++ objfile_extension(), - {ok,Full} = load_mod(Mod, File), - init ! {self(),loaded,{Mod,Full}}, % Tell init about loaded module - eval_script(T, Es); eval_script([{primLoad,Mods}|T], #es{init=Init,prim_load=PrimLoad}=Es) when is_list(Mods) -> case PrimLoad of @@ -873,14 +879,44 @@ eval_script([], #es{}) -> eval_script(What, #es{}) -> exit({'unexpected command in bootfile',What}). -load_modules([Mod|Mods], Init) -> - File = atom_to_list(Mod) ++ objfile_extension(), - {ok,Full} = load_mod(Mod,File), - Init ! {self(),loaded,{Mod,Full}}, %Tell init about loaded module - load_modules(Mods, Init); -load_modules([], _) -> +load_modules(Mods0, Init) -> + Mods = [M || M <- Mods0, not erlang:module_loaded(M)], + F = prepare_loading_fun(), + case erl_prim_loader:get_modules(Mods, F) of + {ok,{Prep0,[]}} -> + Prep = [Code || {_,{prepared,Code,_}} <- Prep0], + ok = erlang:finish_loading(Prep), + Loaded = [{Mod,Full} || {Mod,{_,_,Full}} <- Prep0], + Init ! {self(),loaded,Loaded}, + Beams = [{M,Beam,Full} || {M,{on_load,Beam,Full}} <- Prep0], + load_rest(Beams, Init); + {ok,{_,[_|_]=Errors}} -> + Ms = [M || {M,_} <- Errors], + exit({load_failed,Ms}) + end. + +load_rest([{Mod,Beam,Full}|T], Init) -> + do_load_module(Mod, Beam), + Init ! {self(),loaded,[{Mod,Full}]}, + load_rest(T, Init); +load_rest([], _) -> ok. +prepare_loading_fun() -> + fun(Mod, FullName, Beam) -> + case erlang:prepare_loading(Mod, Beam) of + Prepared when is_binary(Prepared) -> + case erlang:has_prepared_code_on_load(Prepared) of + true -> + {ok,{on_load,Beam,FullName}}; + false -> + {ok,{prepared,Prepared,FullName}} + end; + {error,_}=Error -> + Error + end + end. + make_path(Pa, Pz, Path, Vars) -> append([Pa,append([fix_path(Path,Vars),Pz])]). @@ -1033,35 +1069,17 @@ start_it([_|_]=MFA) -> [M,F|Args] -> M:F(Args) % Args is a list end. -%% -%% Fetch a module and load it into the system. -%% -load_mod(Mod, File) -> - case erlang:module_loaded(Mod) of - false -> - case erl_prim_loader:get_file(File) of - {ok,BinCode,FullName} -> - load_mod_code(Mod, BinCode, FullName); - _ -> - exit({'cannot load',Mod,get_file}) - end; - _ -> % Already loaded. - {ok,File} - end. +%% Load a module. -load_mod_code(Mod, BinCode, FullName) -> - case erlang:module_loaded(Mod) of - false -> - case erlang:load_module(Mod, BinCode) of - {module,Mod} -> {ok,FullName}; - {error,on_load} -> - ?ON_LOAD_HANDLER ! {loaded,Mod}, - {ok,FullName}; - Other -> - exit({'cannot load',Mod,Other}) - end; - _ -> % Already loaded. - {ok,FullName} +do_load_module(Mod, BinCode) -> + case erlang:load_module(Mod, BinCode) of + {module,Mod} -> + ok; + {error,on_load} -> + ?ON_LOAD_HANDLER ! {loaded,Mod}, + ok; + _ -> + error end. %% -------------------------------------------------------- diff --git a/lib/asn1/test/asn1_SUITE.erl b/lib/asn1/test/asn1_SUITE.erl index 7214c4b300..77f78b2716 100644 --- a/lib/asn1/test/asn1_SUITE.erl +++ b/lib/asn1/test/asn1_SUITE.erl @@ -34,7 +34,9 @@ %% Suite definition %%------------------------------------------------------------------------------ -suite() -> [{ct_hooks, [ts_install_cth]}]. +suite() -> + [{ct_hooks, [ts_install_cth]}, + {timetrap,{minutes,60}}]. all() -> [{group, compile}, @@ -194,18 +196,13 @@ end_per_group(_GroupName, Config) -> Config. init_per_testcase(Func, Config) -> - CaseDir = filename:join(?config(priv_dir, Config), Func), + CaseDir = filename:join(proplists:get_value(priv_dir, Config), Func), ok = filelib:ensure_dir(filename:join([CaseDir, dummy_file])), true = code:add_patha(CaseDir), - - Dog = case Func of - testRfcs -> ct:timetrap({minutes, 90}); - _ -> ct:timetrap({minutes, 60}) - end, - [{case_dir, CaseDir}, {watchdog, Dog}|Config]. + [{case_dir, CaseDir}|Config]. end_per_testcase(_Func, Config) -> - code:del_path(?config(case_dir, Config)). + code:del_path(proplists:get_value(case_dir, Config)). %%------------------------------------------------------------------------------ %% Test runners @@ -243,7 +240,7 @@ opts(Rule) when is_atom(Rule) -> []; opts({_Rule, Opts}) -> Opts. run_case(Config, Fun, Rule, Opts) -> - CaseDir = ?config(case_dir, Config), + CaseDir = proplists:get_value(case_dir, Config), Dir = filename:join([CaseDir, join(Rule, Opts)]), ok = filelib:ensure_dir(filename:join([Dir, dummy_file])), replace_path(CaseDir, Dir), @@ -465,7 +462,7 @@ testSeqExtension(Config, Rule, Opts) -> "SeqExtension2"], Config, [Rule|Opts]), - DataDir = ?config(data_dir, Config), + DataDir = proplists:get_value(data_dir, Config), testSeqExtension:main(Rule, DataDir, [Rule|Opts]). testSeqOptional(Config) -> test(Config, fun testSeqOptional/3). @@ -585,8 +582,8 @@ constraint_equivalence(Config, Rule, Opts) -> asn1_test_lib:compile(M, Config, [Rule|Opts]). constraint_equivalence_abs(Config) -> - DataDir = ?config(data_dir, Config), - CaseDir = ?config(case_dir, Config), + DataDir = proplists:get_value(data_dir, Config), + CaseDir = proplists:get_value(case_dir, Config), Asn1Spec = "ConstraintEquivalence", Asn1Src = filename:join(DataDir, Asn1Spec), ok = asn1ct:compile(Asn1Src, [abs,{outdir,CaseDir}]), @@ -637,7 +634,7 @@ module_test(M0, Config, Rule, Opts) -> %% value for 'Filter' is not guaranteed to terminate. ok; M -> - TestOpts = [{i, ?config(case_dir, Config)}], + TestOpts = [{i, proplists:get_value(case_dir, Config)}], case asn1ct:test(M, TestOpts) of ok -> ok; @@ -768,7 +765,7 @@ testInfObjectClass(Config, Rule, Opts) -> testUniqueObjectSets(Config) -> test(Config, fun testUniqueObjectSets/3). testUniqueObjectSets(Config, Rule, Opts) -> - CaseDir = ?config(case_dir, Config), + CaseDir = proplists:get_value(case_dir, Config), testUniqueObjectSets:main(CaseDir, Rule, Opts). testInfObjExtract(Config) -> test(Config, fun testInfObjExtract/3). @@ -993,6 +990,9 @@ testS1AP(Config, Rule, Opts) -> ok end. +testRfcs() -> + [{timetrap,{minutes,90}}]. + testRfcs(Config) -> test(Config, fun testRfcs/3, [{ber,[der]}]). testRfcs(Config, Rule, Opts) -> case erlang:system_info(system_architecture) of @@ -1136,7 +1136,7 @@ test_modules() -> "CCSNARG3"]. test_OTP_9688(Config) -> - PrivDir = ?config(case_dir, Config), + PrivDir = proplists:get_value(case_dir, Config), Data = " OTP-9688 DEFINITIONS ::= BEGIN @@ -1172,12 +1172,10 @@ testTimer_uper(Config) -> testTimer:go(). %% Test of multiple-line comment, OTP-8043 -testComment(suite) -> []; testComment(Config) -> asn1_test_lib:compile("Comment", Config, []), asn1_test_lib:roundtrip('Comment', 'Seq', {'Seq',12,true}). -testName2Number(suite) -> []; testName2Number(Config) -> N2NOptions = [{n2n,Type} || Type <- ['CauseMisc', 'CauseProtocol', 'CauseRadioNetwork', diff --git a/lib/asn1/test/asn1_SUITE_data/test_records.erl b/lib/asn1/test/asn1_SUITE_data/test_records.erl index 65716bb0dc..8f65d887c9 100644 --- a/lib/asn1/test/asn1_SUITE_data/test_records.erl +++ b/lib/asn1/test/asn1_SUITE_data/test_records.erl @@ -45,19 +45,19 @@ check_record_names({initiatingMessage, transactionID = _TransactionID, value = Value}}) -> - ?line ok = check_record_ProcedureID(ProcedureID), - ?line ok = check_record_Value(Value). + ok = check_record_ProcedureID(ProcedureID), + ok = check_record_Value(Value). check_record_ProcedureID(#'ProcedureID'{}) -> ok; check_record_ProcedureID(_) -> false. check_record_Value(#'ResourceStatusIndication'{protocolIEs = ProtocolIEs}) -> - ?line ok = check_record_ProtocolIEs(ProtocolIEs); + ok = check_record_ProtocolIEs(ProtocolIEs); check_record_Value(_) -> false. check_record_ProtocolIEs([#'ProtocolIE-Field'{value =IndicationType}|_]) -> - ?line ok = check_record_NFResourceStatusInd(IndicationType); + ok = check_record_NFResourceStatusInd(IndicationType); check_record_ProtocolIEs(_) -> false. check_record_NFResourceStatusInd({'no-Failure',#'No-Failure-ResourceStatusInd'{'local-Cell-InformationList'=[LCIPF]}}) -> @@ -65,13 +65,13 @@ check_record_NFResourceStatusInd({'no-Failure',#'No-Failure-ResourceStatusInd'{' check_record_NFResourceStatusInd(_) -> false. 'check_record_NFResourceStatusInd_ProtocolIE-Field'(#'ProtocolIE-Field'{value=LCI}) -> - ?line ok = check_record_LCInfoResourceStatusInd(LCI); + ok = check_record_LCInfoResourceStatusInd(LCI); 'check_record_NFResourceStatusInd_ProtocolIE-Field'(_) -> false. check_record_LCInfoResourceStatusInd(#'Local-Cell-InformationItem-ResourceStatusInd'{commonChannelsCapacityConsumptionLaw=[CCCCL],dedicatedChannelsCapacityConsumptionLaw=[DCCCL],'iE-Extensions' = [LCIRE]}) -> - ?line ok = check_record_CCCCL(CCCCL), - ?line ok = check_record_DCCCL(DCCCL), - ?line ok = check_record_LCIRE(LCIRE). + ok = check_record_CCCCL(CCCCL), + ok = check_record_DCCCL(DCCCL), + ok = check_record_LCIRE(LCIRE). check_record_CCCCL(#'CommonChannelsCapacityConsumptionLaw_SEQOF'{}) -> ok; diff --git a/lib/asn1/test/asn1_app_test.erl b/lib/asn1/test/asn1_app_test.erl index 71aad5c62f..f226652b02 100644 --- a/lib/asn1/test/asn1_app_test.erl +++ b/lib/asn1/test/asn1_app_test.erl @@ -42,8 +42,6 @@ end_per_group(_GroupName, Config) -> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -init_per_suite(suite) -> []; -init_per_suite(doc) -> []; init_per_suite(Config) when is_list(Config) -> case is_app(asn1) of {ok, AppFile} -> @@ -64,18 +62,13 @@ is_app(App) -> end. -end_per_suite(suite) -> []; -end_per_suite(doc) -> []; end_per_suite(Config) when is_list(Config) -> Config. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -fields(suite) -> - []; -fields(doc) -> - []; +%% . fields(Config) when is_list(Config) -> AppFile = key1search(app_file, Config), Fields = [vsn, description, modules, registered, applications], @@ -103,10 +96,7 @@ check_field(Name, AppFile, Missing) -> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -modules(suite) -> - []; -modules(doc) -> - []; +%% . modules(Config) when is_list(Config) -> AppFile = key1search(app_file, Config), Mods = key1search(modules, AppFile), @@ -176,10 +166,7 @@ extra_modules(Mods, [Mod|Ebins], Extra) -> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -exportall(suite) -> - []; -exportall(doc) -> - []; +%% . exportall(Config) when is_list(Config) -> AppFile = key1search(app_file, Config), Mods = key1search(modules, AppFile), @@ -209,10 +196,7 @@ check_export_all([Mod|Mods]) -> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -app_depend(suite) -> - []; -app_depend(doc) -> - []; +%% . app_depend(Config) when is_list(Config) -> AppFile = key1search(app_file, Config), Apps = key1search(applications, AppFile), diff --git a/lib/asn1/test/asn1_appup_test.erl b/lib/asn1/test/asn1_appup_test.erl index 7df6190f92..94c84f7c45 100644 --- a/lib/asn1/test/asn1_appup_test.erl +++ b/lib/asn1/test/asn1_appup_test.erl @@ -42,14 +42,10 @@ end_per_group(_GroupName, Config) -> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -init_per_suite(suite) -> []; -init_per_suite(doc) -> []; init_per_suite(Config) when is_list(Config) -> Config. -end_per_suite(suite) -> []; -end_per_suite(doc) -> []; end_per_suite(Config) when is_list(Config) -> Config. diff --git a/lib/asn1/test/asn1_test_lib.erl b/lib/asn1/test/asn1_test_lib.erl index dbb2600b41..21f00b0968 100644 --- a/lib/asn1/test/asn1_test_lib.erl +++ b/lib/asn1/test/asn1_test_lib.erl @@ -34,8 +34,8 @@ run_dialyzer() -> compile(File, Config, Options) -> compile_all([File], Config, Options). compile_all(Files, Config, Options) -> - DataDir = ?config(data_dir, Config), - CaseDir = ?config(case_dir, Config), + DataDir = proplists:get_value(data_dir, Config), + CaseDir = proplists:get_value(case_dir, Config), [compile_file(filename:join(DataDir, F), [{outdir, CaseDir}, debug_info|Options]) || F <- Files], @@ -99,8 +99,8 @@ compile_file(File, Options) -> end. compile_erlang(Mod, Config, Options) -> - DataDir = ?config(data_dir, Config), - CaseDir = ?config(case_dir, Config), + DataDir = proplists:get_value(data_dir, Config), + CaseDir = proplists:get_value(case_dir, Config), M = list_to_atom(Mod), {ok, M} = compile:file(filename:join(DataDir, Mod), [report,{i,CaseDir},{outdir,CaseDir}|Options]). diff --git a/lib/asn1/test/error_SUITE.erl b/lib/asn1/test/error_SUITE.erl index caae845592..a8c6b894f1 100644 --- a/lib/asn1/test/error_SUITE.erl +++ b/lib/asn1/test/error_SUITE.erl @@ -929,8 +929,8 @@ values(Config) -> run({Mod,Spec}, Config) -> Base = atom_to_list(Mod) ++ ".asn1", - File = filename:join(?config(priv_dir, Config), Base), - Include0 = filename:dirname(?config(data_dir, Config)), + File = filename:join(proplists:get_value(priv_dir, Config), Base), + Include0 = filename:dirname(proplists:get_value(data_dir, Config)), Include = filename:join(filename:dirname(Include0), "asn1_SUITE_data"), ok = file:write_file(File, Spec), asn1ct:compile(File, [{i, Include}]). diff --git a/lib/asn1/test/syntax_SUITE.erl b/lib/asn1/test/syntax_SUITE.erl index a354b75062..56b8f32ff7 100644 --- a/lib/asn1/test/syntax_SUITE.erl +++ b/lib/asn1/test/syntax_SUITE.erl @@ -305,7 +305,7 @@ run(List, File, Config) -> run(List, File0, Config, Module) -> Base = File0 ++ ".asn1", - File = filename:join(?config(priv_dir, Config), Base), + File = filename:join(proplists:get_value(priv_dir, Config), Base), case run_1(List, Base, File, Module, 0) of 0 -> ok; Errors -> ?t:fail(Errors) diff --git a/lib/asn1/test/testContextSwitchingTypes.erl b/lib/asn1/test/testContextSwitchingTypes.erl index 3779f61f2f..62fe4c2168 100644 --- a/lib/asn1/test/testContextSwitchingTypes.erl +++ b/lib/asn1/test/testContextSwitchingTypes.erl @@ -38,7 +38,7 @@ test(Config) -> check_EXTERNAL(enc_dec('T', ValT_4)), {ok,ValT2} = asn1ct:value('ContextSwitchingTypes', 'T', - [{i,?config(case_dir, Config)}]), + [{i,proplists:get_value(case_dir, Config)}]), io:format("ValT2 ~p~n",[ValT2]), check_EXTERNAL(enc_dec('T', ValT2)), diff --git a/lib/asn1/test/testMegaco.erl b/lib/asn1/test/testMegaco.erl index 61794ec02d..e298622a0f 100644 --- a/lib/asn1/test/testMegaco.erl +++ b/lib/asn1/test/testMegaco.erl @@ -32,13 +32,13 @@ compile(Config, Erule, Options) -> main(no_module,_) -> ok; main('OLD-MEDIA-GATEWAY-CONTROL',Config) -> - CaseDir = ?config(case_dir, Config), + CaseDir = proplists:get_value(case_dir, Config), {ok,Msg} = asn1ct:value('OLD-MEDIA-GATEWAY-CONTROL','MegacoMessage', [{i, CaseDir}]), asn1_test_lib:roundtrip('OLD-MEDIA-GATEWAY-CONTROL', 'MegacoMessage', Msg), ok; main('MEDIA-GATEWAY-CONTROL'=Mod, Config) -> - DataDir = ?config(data_dir, Config), + DataDir = proplists:get_value(data_dir, Config), Files = filelib:wildcard(filename:join([DataDir,megacomessages,"*.val"])), lists:foreach(fun(File) -> {ok,Bin} = file:read_file(File), diff --git a/lib/asn1/test/testMergeCompile.erl b/lib/asn1/test/testMergeCompile.erl index 5011c7d576..1feac361e1 100644 --- a/lib/asn1/test/testMergeCompile.erl +++ b/lib/asn1/test/testMergeCompile.erl @@ -66,16 +66,16 @@ main(Erule) -> mvrasn(Erule) -> case Erule of ber -> - ?line ok = test(isd), - ?line ok = test(isd2), - ?line ok = test(dsd), - ?line ok = test(ul_res), - ?line ok = test(seqofseq), - ?line ok = test('InsertSubscriberDataArg'); + ok = test(isd), + ok = test(isd2), + ok = test(dsd), + ok = test(ul_res), + ok = test(seqofseq), + ok = test('InsertSubscriberDataArg'); _ -> ok end, - ?line ok = test(mvrasn6,'InsertSubscriberDataArg'). + ok = test(mvrasn6,'InsertSubscriberDataArg'). test(isd)-> EncPdu = <<48,128,129,7,145,148,113,50,1,0,241,131,1,0,176,128,5,0, diff --git a/lib/asn1/test/testNBAPsystem.erl b/lib/asn1/test/testNBAPsystem.erl index 2a7e39597a..956da1e632 100644 --- a/lib/asn1/test/testNBAPsystem.erl +++ b/lib/asn1/test/testNBAPsystem.erl @@ -92,23 +92,23 @@ compile(Config, Options) -> test(_Erule,Config) -> - ?line ok = enc_audit_req_msg(), - ?line ok = cell_setup_req_msg_test(), + ok = enc_audit_req_msg(), + ok = cell_setup_req_msg_test(), ticket_5812(Config). ticket_5812(Config) -> - ?line Msg = v_5812(), + Msg = v_5812(), {ok,B2} = 'NBAP-PDU-Discriptions':encode('NBAP-PDU', Msg), V = <<0,28,74,0,3,48,0,0,1,0,123,64,41,0,0,0,126,64,35,95,208,2,89,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,145,0,1,205,0,0,0,0,2,98,64,1,128>>, - ?line ok = compare(V,B2), + ok = compare(V,B2), {ok,Msg2} = 'NBAP-PDU-Discriptions':decode('NBAP-PDU', B2), - ?line ok = check_record_names(Msg2,Config). + ok = check_record_names(Msg2,Config). enc_audit_req_msg() -> Msg = {initiatingMessage, audit_req_msg()}, {ok,B} = 'NBAP-PDU-Discriptions':encode('NBAP-PDU', Msg), {ok,_Msg} = 'NBAP-PDU-Discriptions':decode('NBAP-PDU', B), - ?line {initiatingMessage, + {initiatingMessage, #'InitiatingMessage'{value=#'AuditRequest'{protocolIEs=[{_,114,ignore,_}], protocolExtensions = asn1_NOVALUE}}} = _Msg, io:format("Msg: ~n~P~n~n_Msg:~n~P~n",[Msg,15,_Msg,15]), @@ -285,8 +285,8 @@ compare(_,_) -> false. check_record_names(Msg,Config) -> - DataDir = ?config(data_dir,Config), - CaseDir = ?config(case_dir,Config), + DataDir = proplists:get_value(data_dir,Config), + CaseDir = proplists:get_value(case_dir,Config), {ok, test_records} = compile:file(filename:join([DataDir, "test_records"]), [{i, CaseDir}]), ok = test_records:'check_record_names_OTP-5812'(Msg). diff --git a/lib/asn1/test/testParameterizedInfObj.erl b/lib/asn1/test/testParameterizedInfObj.erl index 8b0353522d..d7bcde963b 100644 --- a/lib/asn1/test/testParameterizedInfObj.erl +++ b/lib/asn1/test/testParameterizedInfObj.erl @@ -97,7 +97,7 @@ roundtrip(T, V) -> ranap(_Erule) -> PIEVal2 = [{'ProtocolIE-Field',4,ignore,{radioNetwork,'rab-pre-empted'}}], - ?line Val2 = + Val2 = #'InitiatingMessage'{procedureCode=1, criticality=ignore, value=#'Iu-ReleaseCommand'{protocolIEs=PIEVal2, @@ -121,8 +121,8 @@ param2(Config, Erule) -> {'ProtocolIE-Field',101,true}]}), %% Now remove the data after the extension mark in the object set. - DataDir = ?config(data_dir, Config), - CaseDir = ?config(case_dir, Config), + DataDir = proplists:get_value(data_dir, Config), + CaseDir = proplists:get_value(case_dir, Config), Asn1SrcBase = "Param2.asn1", Asn1SrcFile0 = filename:join(DataDir, Asn1SrcBase), {ok,Src0} = file:read_file(Asn1SrcFile0), diff --git a/lib/asn1/test/testRfcs.erl b/lib/asn1/test/testRfcs.erl index fa4389b904..e110f87edd 100644 --- a/lib/asn1/test/testRfcs.erl +++ b/lib/asn1/test/testRfcs.erl @@ -27,11 +27,11 @@ compile(Config, Erules, Options0) -> Options = [no_ok_wrapper|Options0], - DataDir = ?config(data_dir, Config), + DataDir = proplists:get_value(data_dir, Config), Specs0 = filelib:wildcard("*.asn1", filename:join(DataDir, rfcs)), Specs = [filename:join(rfcs, Spec) || Spec <- Specs0], 122 = length(Specs), - CaseDir = ?config(case_dir, Config), + CaseDir = proplists:get_value(case_dir, Config), asn1_test_lib:compile_all(Specs, Config, [Erules,{i,CaseDir}|Options]). test() -> diff --git a/lib/asn1/test/testSSLspecs.erl b/lib/asn1/test/testSSLspecs.erl index 7dc7eedd50..5d5f749d37 100644 --- a/lib/asn1/test/testSSLspecs.erl +++ b/lib/asn1/test/testSSLspecs.erl @@ -26,8 +26,8 @@ -include_lib("common_test/include/ct.hrl"). compile(Config, Options) -> - DataDir = ?config(data_dir, Config), - CaseDir = ?config(case_dir, Config), + DataDir = proplists:get_value(data_dir, Config), + CaseDir = proplists:get_value(case_dir, Config), NewOptions = [{i, DataDir}, {i, CaseDir}|Options], asn1_test_lib:compile_all(["SSL-PKIX", "PKIXAttributeCertificate"], @@ -44,16 +44,16 @@ compile(Config, Options) -> Config, NewOptions). compile_combined(Config, ber=Rule) -> - DataDir = ?config(data_dir, Config), - CaseDir = ?config(case_dir, Config), + DataDir = proplists:get_value(data_dir, Config), + CaseDir = proplists:get_value(case_dir, Config), Options = [{i, CaseDir}, {i, DataDir}, Rule, der, compact_bit_string, asn1config], ok = remove_db_files_combined(CaseDir), asn1_test_lib:compile("OTP-PKIX.set.asn", Config, Options). remove_db_files(Dir) -> - ?line ok = remove_db_file(Dir ++ "PKIX1Explicit93.asn1db"), - ?line ok = remove_db_file(Dir ++ "PKIX1Implicit93.asn1db"). + ok = remove_db_file(Dir ++ "PKIX1Explicit93.asn1db"), + ok = remove_db_file(Dir ++ "PKIX1Implicit93.asn1db"). remove_db_file(File) -> case file:delete(File) of ok -> @@ -65,23 +65,23 @@ remove_db_file(File) -> end. remove_db_files_combined(Dir) -> - ?line ok = remove_db_file(Dir ++ "OTP-PKIX.asn1db"), - ?line ok = remove_db_file(Dir ++ "SSL-PKIX.asn1db"), - ?line ok = remove_db_file(Dir ++ "PKIXAttributeCertificate.asn1db"), - ?line ok = remove_db_file(Dir ++ "PKIX1Algorithms88.asn1db"), - ?line ok = remove_db_file(Dir ++ "PKIX1Explicit88.asn1db"), - ?line ok = remove_db_file(Dir ++ "PKIX1Implicit88.asn1db"). + ok = remove_db_file(Dir ++ "OTP-PKIX.asn1db"), + ok = remove_db_file(Dir ++ "SSL-PKIX.asn1db"), + ok = remove_db_file(Dir ++ "PKIXAttributeCertificate.asn1db"), + ok = remove_db_file(Dir ++ "PKIX1Algorithms88.asn1db"), + ok = remove_db_file(Dir ++ "PKIX1Explicit88.asn1db"), + ok = remove_db_file(Dir ++ "PKIX1Implicit88.asn1db"). run(ber) -> run1(1). run1(6) -> - ?line f1(6), - ?line f2(6), - ?line transform4(ex(7)); + f1(6), + f2(6), + transform4(ex(7)); run1(N) -> - ?line f1(N), - ?line f2(N), + f1(N), + f2(N), run1(N+1). @@ -93,22 +93,22 @@ f2(N) -> transform1(ATAV) -> - ?line {ok, ATAVEnc} = 'PKIX1Explicit88':encode('AttributeTypeAndValue', + {ok, ATAVEnc} = 'PKIX1Explicit88':encode('AttributeTypeAndValue', ATAV), - ?line {ok, _ATAVDec} = 'SSL-PKIX':decode('AttributeTypeAndValue', + {ok, _ATAVDec} = 'SSL-PKIX':decode('AttributeTypeAndValue', ATAVEnc). transform2(ATAV) -> - ?line {ok, ATAVEnc} = 'PKIX1Explicit88':encode('AttributeTypeAndValue', + {ok, ATAVEnc} = 'PKIX1Explicit88':encode('AttributeTypeAndValue', ATAV), - ?line {ok, _ATAVDec} = 'PKIX1Explicit88':decode('AttributeTypeAndValue', + {ok, _ATAVDec} = 'PKIX1Explicit88':decode('AttributeTypeAndValue', ATAVEnc). transform4(ATAV) -> - ?line {ok, ATAVEnc} = 'PKIX1Explicit88':encode('Attribute', + {ok, ATAVEnc} = 'PKIX1Explicit88':encode('Attribute', ATAV), - ?line {ok, _ATAVDec} = 'PKIX1Explicit88':decode('Attribute', + {ok, _ATAVDec} = 'PKIX1Explicit88':decode('Attribute', ATAVEnc). @@ -144,8 +144,8 @@ ex(7) -> run_combined(ber) -> Cert = cert(), - ?line {ok,{'CertificatePKIX1Explicit88',{Type,UnDec},_,_}} = 'OTP-PKIX':decode_TBSCert_exclusive(Cert), - ?line {ok,_} = 'OTP-PKIX':decode_part(Type,UnDec), + {ok,{'CertificatePKIX1Explicit88',{Type,UnDec},_,_}} = 'OTP-PKIX':decode_TBSCert_exclusive(Cert), + {ok,_} = 'OTP-PKIX':decode_part(Type,UnDec), ok. cert() -> diff --git a/lib/asn1/test/testSeqOfIndefinite.erl b/lib/asn1/test/testSeqOfIndefinite.erl index bebd516c5c..e28b9e0fd3 100644 --- a/lib/asn1/test/testSeqOfIndefinite.erl +++ b/lib/asn1/test/testSeqOfIndefinite.erl @@ -25,13 +25,13 @@ -include_lib("common_test/include/ct.hrl"). main() -> - ?line ok = test(isd), - ?line ok = test(isd2), - ?line ok = test(dsd), - ?line ok = test(ul_res), - ?line ok = test(prim), - ?line ok = test(seqofseq), - ?line ok = test('InsertSubscriberDataArg'). % OTP-4232 + ok = test(isd), + ok = test(isd2), + ok = test(dsd), + ok = test(ul_res), + ok = test(prim), + ok = test(seqofseq), + ok = test('InsertSubscriberDataArg'). % OTP-4232 test(isd)-> EncPdu = <<48,128,129,7,145,148,113,50,1,0,241,131,1,0,176,128,5,0, diff --git a/lib/asn1/test/testTCAP.erl b/lib/asn1/test/testTCAP.erl index 6e777875f6..48a9f049ca 100644 --- a/lib/asn1/test/testTCAP.erl +++ b/lib/asn1/test/testTCAP.erl @@ -39,7 +39,6 @@ compile_asn1config(Config, Options) -> asn1_test_lib:compile_erlang("TCAPPackage_msg", Config, []). test(Erule,_Config) -> -% ?line OutDir = ?config(priv_dir,Config), %% testing OTP-4798, open type encoded with indefinite length {ok,_Res} = 'TCAPMessages-simple':decode('MessageType', val_OTP_4798(Erule)), @@ -49,20 +48,17 @@ test(Erule,_Config) -> val_OTP_4799(Erule)), %% testing vance shipley's problems. Parameterized object sets. - ?line Val3 = 'TCAPPackage_msg':val('PackageType',unidirectional), + Val3 = 'TCAPPackage_msg':val('PackageType',unidirectional), Res3 = enc_dec('PackageType', Val3), - ?line ok = 'TCAPPackage_msg':check_result('PackageType',unidirectional,Res3), -%% ?line io:format("Res3:~n~p~n~n",[Res3]), + ok = 'TCAPPackage_msg':check_result('PackageType',unidirectional,Res3), - ?line Val4 = 'TCAPPackage_msg':val('PackageType',abort), + Val4 = 'TCAPPackage_msg':val('PackageType',abort), Res4 = enc_dec('PackageType', Val4), - ?line ok = 'TCAPPackage_msg':check_result('PackageType',abort,Res4), -%% ?line io:format("Res4:~n~p~n~n",[Res4]), + ok = 'TCAPPackage_msg':check_result('PackageType',abort,Res4), - ?line Val5 = 'TCAPPackage_msg':val('PackageType',response), + Val5 = 'TCAPPackage_msg':val('PackageType',response), Res5 = enc_dec('PackageType', Val5), - ?line ok = 'TCAPPackage_msg':check_result('PackageType',response,Res5). -%% ?line io:format("Res5:~n~p~n~n",[Res5]). + ok = 'TCAPPackage_msg':check_result('PackageType',response,Res5). val_OTP_4798(ber) -> [100,129,176,73,4,57,3,17,80,107,42,40,40,6,7,0,17,134,5,1,1,1,160,29,97,27,128,2,7,128,161,9,6,7,4,0,0,1,0,14,2,162,3,2,1,0,163,5,161,3,2,1,0,108,128,162,120,2,1,0,48,115,2,1,56,48,128,48,34,4,16,203,87,215,196,217,93,235,90,64,131,106,145,39,26,25,236,4,4,197,241,81,112,4,8,78,225,34,196,215,212,200,0,48,34,4,16,145,125,27,67,42,144,6,161,207,112,55,75,200,191,191,28,4,4,226,219,242,123,4,8,72,46,130,28,206,178,168,0,48,34,4,16,1,8,20,29,70,160,218,160,125,188,244,174,113,115,253,245,4,4,26,5,90,160,4,8,252,75,149,98,153,224,140,0,0,0,0,0]; diff --git a/lib/asn1/test/test_compile_options.erl b/lib/asn1/test/test_compile_options.erl index 1af614f49a..ea67514229 100644 --- a/lib/asn1/test/test_compile_options.erl +++ b/lib/asn1/test/test_compile_options.erl @@ -39,50 +39,49 @@ wrong_path(Config) -> end. comp(Parent,Config) -> - DataDir = ?config(data_dir,Config), - OutDir = ?config(priv_dir,Config), - ?line Err=asn1ct:compile(DataDir++"NoImport",[{i,OutDir},{i,filename:join([DataDir,"subdir"])},{outdir,OutDir}]), + DataDir = proplists:get_value(data_dir,Config), + OutDir = proplists:get_value(priv_dir,Config), + Err=asn1ct:compile(DataDir++"NoImport",[{i,OutDir},{i,filename:join([DataDir,"subdir"])},{outdir,OutDir}]), Parent!Err. %% OTP-5701 path(Config) -> - DataDir = ?config(data_dir,Config), - OutDir = ?config(priv_dir,Config), + DataDir = proplists:get_value(data_dir,Config), + OutDir = proplists:get_value(priv_dir,Config), {ok,CWD} = file:get_cwd(), - ?line file:set_cwd(filename:join([DataDir,subdir])), + file:set_cwd(filename:join([DataDir,subdir])), ok = asn1ct:compile("../MyMerge.set.asn",[{outdir,OutDir}]), - ?line ok=outfiles_check(OutDir), - ?line outfiles_remove(OutDir), + ok=outfiles_check(OutDir), + outfiles_remove(OutDir), file:set_cwd(filename:join([DataDir,subdir,subsubdir])), ok = asn1ct:compile('../../MyMerge.set.asn',[{i,'..'},{outdir,OutDir}]), - ?line ok=outfiles_check(OutDir,outfiles2()), + ok=outfiles_check(OutDir,outfiles2()), file:set_cwd(CWD), ok. ticket_6143(Config) -> asn1_test_lib:compile("AA1", Config, []). noobj(Config) -> - DataDir = ?config(data_dir,Config), - OutDir = ?config(priv_dir,Config), + DataDir = proplists:get_value(data_dir,Config), + OutDir = proplists:get_value(priv_dir,Config), code:purge('P-Record'), file:delete(filename:join([OutDir,'P-Record.erl'])), file:delete(filename:join([OutDir,'P-Record.beam'])), - ?line ok=asn1ct:compile(filename:join([DataDir,"P-Record"]), + ok=asn1ct:compile(filename:join([DataDir,"P-Record"]), [noobj,{outdir,OutDir}]), -% ?line false = code:is_loaded('P-Record'), - ?line {ok,_} = file:read_file_info(filename:join([OutDir, + {ok,_} = file:read_file_info(filename:join([OutDir, "P-Record.erl"])), - ?line {error,enoent} = + {error,enoent} = file:read_file_info(filename:join([OutDir,"P-Record.beam"])), - ?line {ok,_} = c:c(filename:join([OutDir,'P-Record']), + {ok,_} = c:c(filename:join([OutDir,'P-Record']), [{i,OutDir},{outdir,OutDir}]), - ?line {file,_} = code:is_loaded('P-Record'), + {file,_} = code:is_loaded('P-Record'), code:purge('P-Record'), code:delete('P-Record'), @@ -94,43 +93,41 @@ noobj(Config) -> file:delete(filename:join([OutDir,'p_record.beam'])), ok = asn1ct:compile(filename:join([DataDir,"p_record.set.asn"]), [asn1config,ber,noobj,{outdir,OutDir}]), -%% ?line false = code:is_loaded('P-Record'), -%% ?line false = code:is_loaded('p_record'), - ?line {error,enoent} = + {error,enoent} = file:read_file_info(filename:join([OutDir,"P-Record.beam"])), - ?line {error,enoent} = + {error,enoent} = file:read_file_info(filename:join([OutDir,"P-Record.erl"])), - ?line {error,enoent} = + {error,enoent} = file:read_file_info(filename:join([OutDir,"p_record.beam"])), io:format("read_file_info: p_record.erl~n",[]), - ?line {ok,_} = + {ok,_} = file:read_file_info(filename:join([OutDir,"p_record.erl"])), io:format("c:c: p_record.erl~n",[]), - ?line {ok,_} = c:c(filename:join([OutDir,'p_record']), + {ok,_} = c:c(filename:join([OutDir,'p_record']), [{i,OutDir},{outdir,OutDir}]), io:format("code:is_loaded: p_record.erl~n",[]), - ?line {file,_} = code:is_loaded('p_record'), + {file,_} = code:is_loaded('p_record'), io:format("file:delete: p_record.erl~n",[]), file:delete(filename:join([OutDir,'p_record.erl'])), file:delete(filename:join([OutDir,'p_record.beam'])). verbose(Config) when is_list(Config) -> - DataDir = ?config(data_dir,Config), - OutDir = ?config(priv_dir,Config), + DataDir = proplists:get_value(data_dir,Config), + OutDir = proplists:get_value(priv_dir,Config), Asn1File = filename:join([DataDir,"Comment.asn"]), %% Test verbose compile - ?line test_server:capture_start(), - ?line ok = asn1ct:compile(Asn1File, [{i,DataDir},{outdir,OutDir},noobj,verbose]), - ?line test_server:capture_stop(), - ?line [Line0|_] = test_server:capture_get(), - ?line true = lists:prefix("Erlang ASN.1 compiler", Line0), + test_server:capture_start(), + ok = asn1ct:compile(Asn1File, [{i,DataDir},{outdir,OutDir},noobj,verbose]), + test_server:capture_stop(), + [Line0|_] = test_server:capture_get(), + true = lists:prefix("Erlang ASN.1 compiler", Line0), %% Test non-verbose compile - ?line test_server:capture_start(), - ?line ok = asn1ct:compile(Asn1File, [{i,DataDir},{outdir,OutDir},noobj]), - ?line test_server:capture_stop(), - ?line [] = test_server:capture_get(), + test_server:capture_start(), + ok = asn1ct:compile(Asn1File, [{i,DataDir},{outdir,OutDir},noobj]), + test_server:capture_stop(), + [] = test_server:capture_get(), ok. outfiles_check(OutDir) -> @@ -141,7 +138,7 @@ outfiles_check(_OutDir,[])-> ok; outfiles_check(OutDir,[H|T]) -> io:format("File: ~p~n",[filename:join([OutDir,H])]), - ?line {ok,_}=file:read_file_info(filename:join([OutDir,H])), + {ok,_}=file:read_file_info(filename:join([OutDir,H])), outfiles_check(OutDir,T). outfiles1() -> @@ -155,8 +152,8 @@ outfiles_remove(OutDir) -> outfiles1()). record_name_prefix(Config) -> - DataDir = ?config(data_dir,Config), - OutDir = ?config(priv_dir,Config), + DataDir = proplists:get_value(data_dir,Config), + OutDir = proplists:get_value(priv_dir,Config), ok = b_SeqIn(DataDir,OutDir), ok = a_SeqIn(DataDir,OutDir). @@ -165,15 +162,15 @@ b_SeqIn(DataDir,OutDir) -> [{record_name_prefix,"b_"},{outdir,OutDir}]), io:format("FileName: ~p~nOutDir:~p~n", [filename:join([DataDir,'b_SeqIn']),OutDir]), - ?line {ok,_} = compile:file(filename:join([DataDir,'b_SeqIn']), + {ok,_} = compile:file(filename:join([DataDir,'b_SeqIn']), [{i,OutDir}]), - ?line 'b_SeqIn' = b_SeqIn:record_name(), + 'b_SeqIn' = b_SeqIn:record_name(), ok. a_SeqIn(DataDir,OutDir) -> asn1ct:compile(filename:join([DataDir,'Seq']), [{record_name_prefix,"a_"},{outdir,OutDir}]), - ?line {ok,_} = compile:file(filename:join([DataDir,'a_SeqIn']), + {ok,_} = compile:file(filename:join([DataDir,'a_SeqIn']), [{i,OutDir}]), - ?line 'a_SeqIn' = a_SeqIn:record_name(), + 'a_SeqIn' = a_SeqIn:record_name(), ok. diff --git a/lib/asn1/test/test_modified_x420.erl b/lib/asn1/test/test_modified_x420.erl index c0a32e2a37..a83d522764 100644 --- a/lib/asn1/test/test_modified_x420.erl +++ b/lib/asn1/test/test_modified_x420.erl @@ -24,7 +24,7 @@ -include_lib("common_test/include/ct.hrl"). test(Config) -> - DataDir = ?config(data_dir,Config), + DataDir = proplists:get_value(data_dir,Config), Der = read_pem(filename:join([DataDir,modified_x420,"p7_signed_data.pem"])), {ok,{_,_,SignedData}} = 'PKCS7':decode( 'ContentInfo', Der), diff --git a/lib/asn1/test/test_partial_incomplete_decode.erl b/lib/asn1/test/test_partial_incomplete_decode.erl index 64f2ce22ae..2b1c3bd8c5 100644 --- a/lib/asn1/test/test_partial_incomplete_decode.erl +++ b/lib/asn1/test/test_partial_incomplete_decode.erl @@ -67,7 +67,7 @@ test(Config) -> ok. test_megaco(Config) -> - DataDir = ?config(data_dir, Config), + DataDir = proplists:get_value(data_dir, Config), Files = filelib:wildcard(filename:join([DataDir,megacomessages,"*.val"])), Mod = 'MEDIA-GATEWAY-CONTROL', lists:foreach(fun(File) -> @@ -81,72 +81,72 @@ test_megaco(Config) -> exclusive_decode(Bin,F) -> Mod='MEDIA-GATEWAY-CONTROL', io:format("Encoding message: ~p~n",[F]), - ?line {ok,{_,_,{_,_VsnNo,{MsgMidKey,MsgMid},{MsgMBodyKey,MsgMBody}}}}= + {ok,{_,_,{_,_VsnNo,{MsgMidKey,MsgMid},{MsgMBodyKey,MsgMBody}}}}= Mod:decode_MegacoMessage_exclusive(Bin), - ?line {ok,_} = Mod:decode_part(MsgMidKey,MsgMid), - ?line {ok,_} = Mod:decode_part(MsgMBodyKey,MsgMBody), + {ok,_} = Mod:decode_part(MsgMidKey,MsgMid), + {ok,_} = Mod:decode_part(MsgMBodyKey,MsgMBody), ok. decode_parts('F',PartDecMsg) -> - ?line {fb,{'E',35,{NameE_b,ListBinE_b},false,{NameE_d,BinE_d}}} = PartDecMsg, - ?line {ok,[{'D',3,true}|_]} = 'PartialDecSeq':decode_part(NameE_b,ListBinE_b), - ?line {ok,{'D',3,true}} = 'PartialDecSeq':decode_part(NameE_b, + {fb,{'E',35,{NameE_b,ListBinE_b},false,{NameE_d,BinE_d}}} = PartDecMsg, + {ok,[{'D',3,true}|_]} = 'PartialDecSeq':decode_part(NameE_b,ListBinE_b), + {ok,{'D',3,true}} = 'PartialDecSeq':decode_part(NameE_b, hd(ListBinE_b)), - ?line {ok,{da,[{'A',16,{'D',17,true}}]}} = + {ok,{da,[{'A',16,{'D',17,true}}]}} = 'PartialDecSeq':decode_part(NameE_d,BinE_d), ok; decode_parts('F2',PartDecMsg) -> - ?line {fb,{'E',35,{E_bkey,E_b},false,{da,{E_d_akey,E_d_a}}}} = PartDecMsg, - ?line {ok,[{'D',3,true},{'D',4,false},{'D',5,true},{'D',6,true},{'D',7,false},{'D',8,true},{'D',9,true},{'D',10,false},{'D',11,true},{'D',12,true},{'D',13,false},{'D',14,true}]} = 'PartialDecSeq':decode_part(E_bkey,E_b), - ?line {ok,[{'A',16,{'D',17,true}}]} = 'PartialDecSeq':decode_part(E_d_akey,E_d_a); + {fb,{'E',35,{E_bkey,E_b},false,{da,{E_d_akey,E_d_a}}}} = PartDecMsg, + {ok,[{'D',3,true},{'D',4,false},{'D',5,true},{'D',6,true},{'D',7,false},{'D',8,true},{'D',9,true},{'D',10,false},{'D',11,true},{'D',12,true},{'D',13,false},{'D',14,true}]} = 'PartialDecSeq':decode_part(E_bkey,E_b), + {ok,[{'A',16,{'D',17,true}}]} = 'PartialDecSeq':decode_part(E_d_akey,E_d_a); decode_parts('F3',PartDecMsg) -> - ?line {fb,{'E',10,{E_bkey,E_b},false,{dc,{'E_d_dc',13,true,{E_d_dc_dcckey,E_d_dc_dcc}}}}} = PartDecMsg, - ?line {ok,[{'D',11,true},{'D',12,false}]} = 'PartialDecSeq':decode_part(E_bkey,E_b), - ?line {ok,{'E_d_dc_dcc',14,15}} = 'PartialDecSeq':decode_part(E_d_dc_dcckey,E_d_dc_dcc); + {fb,{'E',10,{E_bkey,E_b},false,{dc,{'E_d_dc',13,true,{E_d_dc_dcckey,E_d_dc_dcc}}}}} = PartDecMsg, + {ok,[{'D',11,true},{'D',12,false}]} = 'PartialDecSeq':decode_part(E_bkey,E_b), + {ok,{'E_d_dc_dcc',14,15}} = 'PartialDecSeq':decode_part(E_d_dc_dcckey,E_d_dc_dcc); decode_parts('D',PartDecMsg) -> - ?line {'D',{NameD_a,BinD_a},true} = PartDecMsg, - ?line {ok,123} = 'PartialDecSeq':decode_part(NameD_a,BinD_a), + {'D',{NameD_a,BinD_a},true} = PartDecMsg, + {ok,123} = 'PartialDecSeq':decode_part(NameD_a,BinD_a), ok; decode_parts('A',PartDecMsg) -> - ?line {'A',12,{c,{'S',true,false}},{b,{NameA_c_b,BinA_c_b}}} = PartDecMsg, - ?line {ok,{'A_c_b',false,false}} = + {'A',12,{c,{'S',true,false}},{b,{NameA_c_b,BinA_c_b}}} = PartDecMsg, + {ok,{'A_c_b',false,false}} = 'PartialDecSeq2':decode_part(NameA_c_b,BinA_c_b), ok; decode_parts('GetRequest',PartDecMsg) -> - ?line {'GetRequest',true,false, + {'GetRequest',true,false, {'AcceptTypes',[html,'plain-text',gif,jpeg], {NameAcceptTypes_others,ListBinAcceptTypes_others}}, "IamfineThankYOu"} = PartDecMsg, - ?line {ok,["hell","othe","reho","peyo","uare","fine"]} = + {ok,["hell","othe","reho","peyo","uare","fine"]} = 'PartialDecMyHTTP':decode_part(NameAcceptTypes_others, ListBinAcceptTypes_others), - ?line {ok,"hell"} = + {ok,"hell"} = 'PartialDecMyHTTP':decode_part(NameAcceptTypes_others, hd(ListBinAcceptTypes_others)), ok; decode_parts('S1_1',PartDecMsg) -> - ?line {'S1',14,{'S2',false,12,{NameS2c,BinS2c}}, + {'S1',14,{'S2',false,12,{NameS2c,BinS2c}}, {_,{NameS1c_a,ListBinS1c_a}},{NameS1d,BinS1d}} = PartDecMsg, - ?line {ok,[{'S3',10,"PrintableString","OCTETSTRING", + {ok,[{'S3',10,"PrintableString","OCTETSTRING", [one,two,three,four]}|_Rest1]} = 'PartialDecSeq3':decode_part(NameS2c,BinS2c), - ?line {ok,[{'S3',10,"PrintableString","OCTETSTRING", + {ok,[{'S3',10,"PrintableString","OCTETSTRING", [one,two,three,four]}|_Rest2]} = 'PartialDecSeq3':decode_part(NameS1c_a,ListBinS1c_a), - ?line {ok,{'S3',10,"PrintableString","OCTETSTRING", + {ok,{'S3',10,"PrintableString","OCTETSTRING", [one,two,three,four]}} = 'PartialDecSeq3':decode_part(NameS1c_a,hd(ListBinS1c_a)), - ?line {ok,[{'Name',"Hans","HCA","Andersen"}|_Rest3]} = + {ok,[{'Name',"Hans","HCA","Andersen"}|_Rest3]} = 'PartialDecSeq3':decode_part(NameS1d,BinS1d), ok; decode_parts('S1_2',PartDecMsg) -> - ?line {'S1',14,{'S2',false,12,_S2c},S1c_b,{NameS1d,BinS1d}} = PartDecMsg, - ?line {b,{'C1_b',11,true, + {'S1',14,{'S2',false,12,_S2c},S1c_b,{NameS1d,BinS1d}} = PartDecMsg, + {b,{'C1_b',11,true, {'S4',{'Name',"Hans","HCA","Andersen"},"MSc"}}}=S1c_b, - ?line {ok,[{'Name',"Hans","HCA","Andersen"}|_Rest3]} = + {ok,[{'Name',"Hans","HCA","Andersen"}|_Rest3]} = 'PartialDecSeq3':decode_part(NameS1d,BinS1d), ok. diff --git a/lib/asn1/test/test_special_decode_performance.erl b/lib/asn1/test/test_special_decode_performance.erl index 6cf7ee2805..55e64b61e0 100644 --- a/lib/asn1/test/test_special_decode_performance.erl +++ b/lib/asn1/test/test_special_decode_performance.erl @@ -27,29 +27,29 @@ go(all) -> {Time_S_s,Time_S_e,Time_S_c}=go(10000,'PartialDecSeq'), {Time_MGC_s,Time_MGC_e,Time_MGC_c}=go(10000,'MEDIA-GATEWAY-CONTROL'), - ?line do_comment({Time_S_s,Time_MGC_s}, + do_comment({Time_S_s,Time_MGC_s}, {Time_S_e,Time_MGC_e}, {Time_S_c,Time_MGC_c}). go(N,Mod) -> {Type,Val} = val(Mod), {ok,B} = Mod:encode(Type, Val), - ?line go(Mod,B,N). + go(Mod,B,N). go(Mod,Bin,N) -> - ?line FsS = get_selective_funcs(Mod), - ?line FsE = get_exclusive_funcs(Mod), - ?line io:format("~nSize of value for module ~p: ~p bytes.~n~n",[Mod,size(Bin)]), - ?line Time_s=go1(selective,Mod,FsS,Bin,N,0), - ?line Time_e=go1(exclusive,Mod,FsE,Bin,N,0), - ?line Time_c=go1(common,Mod,[decode],Bin,N,0), - ?line {Time_s/length(FsS),Time_e/length(FsE),Time_c}. + FsS = get_selective_funcs(Mod), + FsE = get_exclusive_funcs(Mod), + io:format("~nSize of value for module ~p: ~p bytes.~n~n",[Mod,size(Bin)]), + Time_s=go1(selective,Mod,FsS,Bin,N,0), + Time_e=go1(exclusive,Mod,FsE,Bin,N,0), + Time_c=go1(common,Mod,[decode],Bin,N,0), + {Time_s/length(FsS),Time_e/length(FsE),Time_c}. go1(_,_,[],_,_,AccTime) -> - ?line AccTime; + AccTime; %% go1 for common decode go1(common,Mod,_,Bin,N,_) -> - ?line TT=get_top_type(Mod), + TT=get_top_type(Mod), {Time,Result} = timer:tc(fun() -> loop1(Mod, decode, TT, Bin, N) end), case Result of {ok,_R1} -> diff --git a/lib/asn1/test/test_undecoded_rest.erl b/lib/asn1/test/test_undecoded_rest.erl index 77147d59cc..9711fd3e8c 100644 --- a/lib/asn1/test/test_undecoded_rest.erl +++ b/lib/asn1/test/test_undecoded_rest.erl @@ -29,7 +29,7 @@ test(Opts, Config) -> {ok,Msg} = asn1ct:value('P-Record', 'PersonnelRecord', - [{i,?config(case_dir, Config)}]), + [{i,proplists:get_value(case_dir, Config)}]), Bytes0 = encode(Opts, 'PersonnelRecord', Msg), Bytes1 = iolist_to_binary([Bytes0, <<55,55,55>>]), case proplists:get_bool(undec_rest, Opts) of diff --git a/lib/common_test/test_server/ts_autoconf_win32.erl b/lib/common_test/test_server/ts_autoconf_win32.erl index 288305b406..26ab30f987 100644 --- a/lib/common_test/test_server/ts_autoconf_win32.erl +++ b/lib/common_test/test_server/ts_autoconf_win32.erl @@ -139,15 +139,15 @@ visual_cxx(Vars) -> {"-MTd ", "-MDd ", "-LDd ", - "-debug -pdb:none ", + "-link -debug -pdb:none ", "-Z7 -DDEBUG", " "}; false -> {"-MT ", "-MD ", "-LD ", - " ", - " ", + "-Zi -link ", + "-Zi ", "-Ox "} end, WIN32 = "-D__WIN32__ ", @@ -158,7 +158,7 @@ visual_cxx(Vars) -> {'LD', CC}, {'SHLIB_LD', CC}, {'SHLIB_LDFLAGS', ERTS_THR_LIB ++ DLL}, - {'SHLIB_LDLIBS', "-link " ++ DBG_LINK ++ "kernel32.lib"}, + {'SHLIB_LDLIBS', DBG_LINK ++ "kernel32.lib"}, {'SHLIB_EXTRACT_ALL', ""}, {'CFLAGS', DEFAULT_THR_LIB ++ WIN32 ++ DBG_COMP}, {'EI_CFLAGS', DEFAULT_THR_LIB ++ WIN32 ++ DBG_COMP}, @@ -168,7 +168,7 @@ visual_cxx(Vars) -> {'DEFS', common_c_defs()}, {'SHLIB_SUFFIX', ".dll"}, {'ERTS_LIBS', ERTS_THR_LIB ++ LIBS}, - {'LIBS', DEFAULT_THR_LIB ++ "-link " ++ DBG_LINK ++ LIBS}, + {'LIBS', DEFAULT_THR_LIB ++ DBG_LINK ++ LIBS}, {obj,".obj"}, {exe, ".exe"}, {test_c_compiler, "{msc, undefined}"} diff --git a/lib/compiler/src/beam_asm.erl b/lib/compiler/src/beam_asm.erl index 95be471de3..28fd061bdc 100644 --- a/lib/compiler/src/beam_asm.erl +++ b/lib/compiler/src/beam_asm.erl @@ -225,10 +225,14 @@ flatten_imports(Imps) -> list_to_binary(map(fun({M,F,A}) -> <<M:32,F:32,A:32>> end, Imps)). build_attributes(Opts, SourceFile, Attr, MD5) -> + Misc0 = case SourceFile of + [] -> []; + [_|_] -> [{source,SourceFile}] + end, Misc = case member(slim, Opts) of false -> {{Y,Mo,D},{H,Mi,S}} = erlang:universaltime(), - [{time,{Y,Mo,D,H,Mi,S}},{source,SourceFile}]; + [{time,{Y,Mo,D,H,Mi,S}}|Misc0]; true -> [] end, Compile = [{options,Opts},{version,?COMPILER_VSN}|Misc], diff --git a/lib/compiler/src/compile.erl b/lib/compiler/src/compile.erl index 46917905de..65566df025 100644 --- a/lib/compiler/src/compile.erl +++ b/lib/compiler/src/compile.erl @@ -1328,7 +1328,7 @@ save_core_code(St) -> beam_asm(#compile{ifile=File,code=Code0, abstract_code=Abst,mod_options=Opts0}=St) -> - Source = filename:absname(File), + Source = paranoid_absname(File), Opts1 = lists:map(fun({debug_info_key,_}) -> {debug_info_key,'********'}; (Other) -> Other end, Opts0), @@ -1337,6 +1337,16 @@ beam_asm(#compile{ifile=File,code=Code0, {ok,Code} -> {ok,St#compile{code=Code,abstract_code=[]}} end. +paranoid_absname(""=File) -> + File; +paranoid_absname(File) -> + case file:get_cwd() of + {ok,Cwd} -> + filename:absname(File, Cwd); + _ -> + File + end. + test_native(#compile{options=Opts}) -> %% This test is done late, in case some other option has turned off native. %% 'native' given on the command line can be overridden by @@ -1681,6 +1691,7 @@ help(_) -> %% Compile entry point for erl_compile. compile(File0, _OutFile, Options) -> + pre_load(), File = shorten_filename(File0), case file(File, make_erl_options(Options)) of {ok,_Mod} -> ok; @@ -1745,3 +1756,46 @@ make_erl_options(Opts) -> end, Options ++ [report_errors, {cwd, Cwd}, {outdir, Outdir}| [{i, Dir} || Dir <- Includes]] ++ Specific. + +pre_load() -> + L = [beam_a, + beam_asm, + beam_block, + beam_bool, + beam_bs, + beam_bsm, + beam_clean, + beam_dead, + beam_dict, + beam_except, + beam_flatten, + beam_jump, + beam_opcodes, + beam_peep, + beam_receive, + beam_reorder, + beam_split, + beam_trim, + beam_type, + beam_utils, + beam_validator, + beam_z, + cerl, + cerl_clauses, + cerl_sets, + cerl_trees, + core_lib, + epp, + erl_bifs, + erl_expand_records, + erl_lint, + erl_parse, + erl_scan, + sys_core_dsetel, + sys_core_fold, + sys_pre_expand, + v3_codegen, + v3_core, + v3_kernel, + v3_life], + code:ensure_modules_loaded(L). diff --git a/lib/compiler/test/compile_SUITE.erl b/lib/compiler/test/compile_SUITE.erl index b2e9558cba..f1e75771bf 100644 --- a/lib/compiler/test/compile_SUITE.erl +++ b/lib/compiler/test/compile_SUITE.erl @@ -22,6 +22,7 @@ %% Tests compile:file/1 and compile:file/2 with various options. -include_lib("common_test/include/ct.hrl"). +-include_lib("stdlib/include/erl_compile.hrl"). -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, init_per_group/2,end_per_group/2, @@ -32,7 +33,7 @@ strict_record/1, missing_testheap/1, cover/1, env/1, core/1, asm/1, sys_pre_attributes/1, dialyzer/1, - warnings/1 + warnings/1, pre_load_check/1 ]). -export([init/3]). @@ -50,7 +51,7 @@ all() -> other_output, encrypted_abstr, strict_record, missing_testheap, cover, env, core, asm, - sys_pre_attributes, dialyzer, warnings]. + sys_pre_attributes, dialyzer, warnings, pre_load_check]. groups() -> []. @@ -126,13 +127,39 @@ forms_2(Config) when is_list(Config) -> Src = "/foo/bar", AbsSrc = filename:absname(Src), Anno = erl_anno:new(1), - {ok,simple,Binary} = compile:forms([{attribute,Anno,module,simple}], - [binary,{source,Src}]), - code:load_binary(simple, Src, Binary), - Info = simple:module_info(compile), + SimpleCode = [{attribute,Anno,module,simple}], + {ok,simple,Bin1} = compile:forms(SimpleCode, [binary,{source,Src}]), - %% Test that the proper source is returned. - AbsSrc = proplists:get_value(source, Info), + %% Load and test that the proper source is returned. + AbsSrc = forms_load_code(simple, Src, Bin1), + + %% Work in a deleted directory. + PrivDir = proplists:get_value(priv_dir, Config), + WorkDir = filename:join(PrivDir, ?FUNCTION_NAME), + ok = file:make_dir(WorkDir), + ok = file:set_cwd(WorkDir), + case os:type() of + {unix,_} -> os:cmd("rm -rf " ++ WorkDir); + _ -> ok + end, + {ok,simple,Bin2} = compile:forms(SimpleCode), + undefined = forms_load_code(simple, "ignore", Bin2), + + {ok,simple,Bin3} = compile:forms(SimpleCode, [{source,Src},report]), + case forms_load_code(simple, "ignore", Bin3) of + Src -> %Unix. + ok; + AbsSrc -> %Windows. + ok + end, + + ok. + + +forms_load_code(Mod, Src, Bin) -> + {module,Mod} = code:load_binary(Mod, Src, Bin), + Info = Mod:module_info(compile), + SourceOption = proplists:get_value(source, Info), %% Ensure that the options are not polluted with 'source'. [] = proplists:get_value(options, Info), @@ -140,7 +167,9 @@ forms_2(Config) when is_list(Config) -> %% Cleanup. true = code:delete(simple), false = code:purge(simple), - ok. + + SourceOption. + module_mismatch(Config) when is_list(Config) -> DataDir = proplists:get_value(data_dir, Config), @@ -881,6 +910,115 @@ do_warnings_2([], Next, F) -> do_warnings_1(Next, F). +%% Test that the compile:pre_load/0 function (used by 'erlc') +%% pre-loads the modules that are used by a typical compilation. + +pre_load_check(Config) -> + case test_server:is_cover() of + true -> + {skip,"Cover is running"}; + false -> + try + do_pre_load_check(Config) + after + dbg:stop_clear() + end + end. + +do_pre_load_check(Config) -> + DataDir = ?config(data_dir, Config), + Simple = filename:join(DataDir, "simple.erl"), + Big = filename:join(DataDir, "big.erl"), + {ok,_} = dbg:tracer(process, {fun pre_load_trace/2,[]}), + dbg:p(self(), call), + dbg:p(new, call), + {ok,_} = dbg:tpl({?MODULE,get_trace_data,0}, []), + {ok,_} = dbg:tp({code,ensure_modules_loaded,1}, []), + + %% Compile a simple module using the erl_compile interface + %% to find out the modules that are pre-loaded by + %% compile:pre_load/0. + Opts = #options{specific=[binary]}, + {ok,simple,_} = compile:compile(Simple, "", Opts), + [{code,ensure_modules_loaded,[PreLoaded0]}] = get_trace_data(), + PreLoaded1 = ordsets:from_list(PreLoaded0), + + %% Since 'compile' is the function doing the pre-loaded, + %% it is useless to include it in the list. + case ordsets:is_element(compile, PreLoaded1) of + true -> + io:put_chars("The 'compile' module should not be included " + "in the list of modules to be pre-loaded."), + ?t:fail(compile); + false -> + [] + end, + PreLoaded = ordsets:add_element(compile, PreLoaded1), + + %% Now unload all pre-loaded modules and all modules in + %% compiler application. Then compile a module to find + %% which modules that get loaded. + CompilerMods = compiler_modules(), + Unload = ordsets:union(ordsets:from_list(CompilerMods), PreLoaded), + _ = [begin + code:delete(M), + code:purge(M) + end || M <- Unload], + + {ok,_} = dbg:ctp({code,ensure_modules_loaded,1}), + {ok,_} = dbg:tp({code,ensure_loaded,1}, []), + {ok,big,_} = compile:file(Big, [binary]), + WasLoaded0 = get_trace_data(), + WasLoaded1 = [M || {code,ensure_loaded,[M]} <- WasLoaded0], + WasLoaded = ordsets:from_list(WasLoaded1), + + %% Check for modules that should have been pre-loaded. + case ordsets:subtract(WasLoaded, PreLoaded) of + [] -> + ok; + [_|_]=NotPreLoaded -> + io:format("The following modules were used " + "but not pre-loaded:\n~p\n", + [NotPreLoaded]), + ?t:fail({not_preload,NotPreLoaded}) + end, + + %% Check for modules that should not be pre-loaded. + case ordsets:subtract(PreLoaded, WasLoaded) of + [] -> + ok; + [_|_]=NotUsed -> + io:format("The following modules were pre-loaded" + " but not used:\n~p\n", + [NotUsed]), + ?t:fail({not_used,NotUsed}) + end, + + ok. + +get_trace_data() -> + %% Apparantely, doing a receive at the beginning of + %% a traced function can cause extra trace messages. + %% To avoid that, don't do the receive in this function. + do_get_trace_data(). + +do_get_trace_data() -> + receive + {trace_data,Data} -> Data + end. + +pre_load_trace({trace,Pid,call,{?MODULE,get_trace_data,[]}}, Acc) -> + Pid ! {trace_data,Acc}, + []; +pre_load_trace({trace,_,call,MFA}, Acc) -> + [MFA|Acc]. + +compiler_modules() -> + Wc = filename:join([code:lib_dir(compiler),"ebin","*.beam"]), + Ms = filelib:wildcard(Wc), + FN = filename, + [list_to_atom(FN:rootname(FN:basename(M), ".beam")) || M <- Ms]. + %%% %%% Utilities. %%% diff --git a/lib/erl_interface/test/all_SUITE_data/ei_runner.c b/lib/erl_interface/test/all_SUITE_data/ei_runner.c index 3a0de22df4..2b0d6c856a 100644 --- a/lib/erl_interface/test/all_SUITE_data/ei_runner.c +++ b/lib/erl_interface/test/all_SUITE_data/ei_runner.c @@ -198,8 +198,8 @@ void free_packet(char* packet) * ----- ---------------------------- * [$b|Bytes] {bytes, Bytes} * [$e] eot - * [$f] test_server:fail() - * [$f|Reason] test_server:fail(Reason) + * [$f] ct:fail() + * [$f|Reason] ct:fail(Reason) * [$t|EncodedTerm] {term, Term} * [$N] 'NULL' * [$m|Message] io:format("~s", [Message]) (otherwise ignored) @@ -211,7 +211,7 @@ void free_packet(char* packet) * you implement a test case entirely in C code. * * If the ok argument is zero, a [$f] reply will be sent to the - * Erlang side (causing test_server:fail() to be called); otherwise, + * Erlang side (causing ct:fail() to be called); otherwise, * the atom 'eot' will be sent to Erlang. * * If you need to provide more details on a failure, use the fail() function. @@ -251,7 +251,7 @@ do_report(file, line, ok) /* - * This function causes a call to test_server:fail(Reason) on the + * This function causes a call to ct:fail(Reason) on the * Erlang side. */ diff --git a/lib/erl_interface/test/all_SUITE_data/runner.c b/lib/erl_interface/test/all_SUITE_data/runner.c index 47d918308d..2332db2220 100644 --- a/lib/erl_interface/test/all_SUITE_data/runner.c +++ b/lib/erl_interface/test/all_SUITE_data/runner.c @@ -200,8 +200,8 @@ char *read_packet(int *len) * ----- ---------------------------- * [$b|Bytes] {bytes, Bytes} * [$e] eot - * [$f] test_server:fail() - * [$f|Reason] test_server:fail(Reason) + * [$f] ct:fail() + * [$f|Reason] ct:fail(Reason) * [$t|EncodedTerm] {term, Term} * [$N] 'NULL' * [$m|Message] io:format("~s", [Message]) (otherwise ignored) @@ -213,7 +213,7 @@ char *read_packet(int *len) * you implement a test case entirely in C code. * * If the ok argument is zero, a [$f] reply will be sent to the - * Erlang side (causing test_server:fail() to be called); otherwise, + * Erlang side (causing ct:fail() to be called); otherwise, * the atom 'eot' will be sent to Erlang. * * If you need to provide more details on a failure, use the fail() function. @@ -253,7 +253,7 @@ do_report(file, line, ok) /* - * This function causes a call to test_server:fail(Reason) on the + * This function causes a call to ct:fail(Reason) on the * Erlang side. */ diff --git a/lib/erl_interface/test/ei_accept_SUITE.erl b/lib/erl_interface/test/ei_accept_SUITE.erl index db3587339e..654f2a4235 100644 --- a/lib/erl_interface/test/ei_accept_SUITE.erl +++ b/lib/erl_interface/test/ei_accept_SUITE.erl @@ -24,94 +24,67 @@ -include_lib("common_test/include/ct.hrl"). -include("ei_accept_SUITE_data/ei_accept_test_cases.hrl"). --export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - init_per_testcase/2, end_per_testcase/2, - ei_accept/1, ei_threaded_accept/1]). +-export([all/0, suite/0, + ei_accept/1, ei_threaded_accept/1]). -import(runner, [get_term/1,send_term/2]). -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}, + {timetrap, {seconds, 30}}]. all() -> [ei_accept, ei_threaded_accept]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - - -init_per_testcase(_Case, Config) -> - Dog = ?t:timetrap(?t:seconds(30)), - [{watchdog, Dog}|Config]. - -end_per_testcase(_Case, Config) -> - Dog = ?config(watchdog, Config), - test_server:timetrap_cancel(Dog), - ok. - ei_accept(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), - - ?line Myname= hd(tl(string:tokens(atom_to_list(node()), "@"))), - ?line io:format("Myname ~p ~n", [Myname]), - ?line EINode= list_to_atom("c42@"++Myname), - ?line io:format("EINode ~p ~n", [EINode]), - ?line Self= self(), - ?line TermToSend= {call, Self, "Test"}, - ?line F= fun() -> - case waitfornode("c42",20) of - true -> - {any, EINode} ! TermToSend, - Self ! sent_ok; - false -> - Self ! never_published - end, - ok - end, - - ?line spawn(F), - ?line Port = 6543, - ?line {ok, Fd, _Node} = ei_accept(P, Port), - ?line TermReceived= ei_receive(P, Fd), - ?line io:format("Sent ~p received ~p ~n", [TermToSend, TermReceived]), - ?line TermToSend= TermReceived, - ?line receive - sent_ok -> - ok; - Unknown -> - io:format("~p ~n", [Unknown]) - after 1000 -> - io:format("timeout ~n") - end, - ?line runner:finish(P), + P = runner:start(?interpret), + 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), + + Myname = hd(tl(string:tokens(atom_to_list(node()), "@"))), + io:format("Myname ~p ~n", [Myname]), + EINode = list_to_atom("c42@"++Myname), + io:format("EINode ~p ~n", [EINode]), + Self = self(), + TermToSend= {call, Self, "Test"}, + F= fun() -> + case waitfornode("c42",20) of + true -> + {any, EINode} ! TermToSend, + Self ! sent_ok; + false -> + Self ! never_published + end, + ok + end, + + spawn(F), + Port = 6543, + {ok, Fd, _Node} = ei_accept(P, Port), + TermReceived= ei_receive(P, Fd), + io:format("Sent ~p received ~p ~n", [TermToSend, TermReceived]), + TermToSend= TermReceived, + receive + sent_ok -> + ok; + Unknown -> + io:format("~p ~n", [Unknown]) + after 1000 -> + io:format("timeout ~n") + end, + runner:finish(P), ok. ei_threaded_accept(Config) when is_list(Config) -> - ?line Einode = filename:join(?config(data_dir, Config), "eiaccnode"), - ?line N = 1, % 3, - ?line Host = atom_to_list(node()), - ?line Port = 6767, - ?line start_einode(Einode, N, Host, Port), - ?line io:format("started eiaccnode"), - %%?line spawn_link(fun() -> start_einode(Einode, N, Host, Port) end), - ?line TestServerPid = self(), - ?line [ spawn_link(fun() -> send_rec_einode(I, TestServerPid) end) - || I <- lists:seq(0, N-1) ], - ?line [ receive I -> ok end - || I <- lists:seq(0, N-1) ], + Einode = filename:join(proplists:get_value(data_dir, Config), "eiaccnode"), + N = 1, % 3, + Host = atom_to_list(node()), + Port = 6767, + start_einode(Einode, N, Host, Port), + io:format("started eiaccnode"), + %%spawn_link(fun() -> start_einode(Einode, N, Host, Port) end), + TestServerPid = self(), + [spawn_link(fun() -> send_rec_einode(I, TestServerPid) end) || I <- lists:seq(0, N-1)], + [receive I -> ok end || I <- lists:seq(0, N-1) ], ok. waitfornode(String,0) -> @@ -120,66 +93,61 @@ waitfornode(String,0) -> waitfornode(String,N) -> Registered = [X || {X,_} <- element(2,erl_epmd:names())], case lists:member(String,Registered) of - true -> - true; - false -> - timer:sleep(1000), - waitfornode(String,N-1) + true -> + true; + false -> + timer:sleep(1000), + waitfornode(String,N-1) end. send_rec_einode(N, TestServerPid) -> - ?line Myname= hd(tl(string:tokens(atom_to_list(node()), "@"))), - ?line FirstPart = "eiacc" ++ integer_to_list(N), - ?line EINode= list_to_atom(FirstPart ++ "@" ++ Myname), - ?line io:format("EINode ~p ~n", [EINode]), - ?line Self= self(), - ?line case waitfornode(FirstPart,20) of - true -> ok; - false -> test_server:fail({never_published,EINode}) - end, - ?line {any, EINode} ! Self, - ?line receive - {N,_}=X -> - ?line io:format("Received by ~s ~p~n", [EINode, X]), - ?line TestServerPid ! N, - ?line X - after 10000 -> - ?line test_server:fail(EINode) - end. + Myname= hd(tl(string:tokens(atom_to_list(node()), "@"))), + FirstPart = "eiacc" ++ integer_to_list(N), + EINode= list_to_atom(FirstPart ++ "@" ++ Myname), + io:format("EINode ~p ~n", [EINode]), + Self= self(), + case waitfornode(FirstPart,20) of + true -> ok; + false -> ct:fail({never_published,EINode}) + end, + {any, EINode} ! Self, + receive + {N,_}=X -> + io:format("Received by ~s ~p~n", [EINode, X]), + TestServerPid ! N, + X + after 10000 -> + ct:fail(EINode) + end. start_einode(Einode, N, Host, Port) -> Einodecmd = Einode ++ " " ++ atom_to_list(erlang:get_cookie()) - ++ " " ++ integer_to_list(N) ++ " " ++ Host ++ " " - ++ integer_to_list(Port) ++ " nothreads", + ++ " " ++ integer_to_list(N) ++ " " ++ Host ++ " " + ++ integer_to_list(Port) ++ " nothreads", io:format("Einodecmd ~p ~n", [Einodecmd]), - ?line open_port({spawn, Einodecmd}, []), + open_port({spawn, Einodecmd}, []), ok. - %%% Interface functions for ei (erl_interface) functions. ei_connect_init(P, Num, Cookie, Creation) -> send_command(P, ei_connect_init, [Num,Cookie,Creation]), case get_term(P) of - {term,Int} when is_integer(Int) -> Int + {term,Int} when is_integer(Int) -> Int end. ei_accept(P, PortNo) -> send_command(P, ei_accept, [PortNo]), case get_term(P) of - {term,{Fd, _, Node}} when Fd >= 0 -> {ok, Fd, Node}; - {term,{_Fd, Errno, _Node}} -> {error,Errno} + {term,{Fd, _, Node}} when Fd >= 0 -> {ok, Fd, Node}; + {term,{_Fd, Errno, _Node}} -> {error,Errno} end. ei_receive(P, Fd) -> send_command(P, ei_receive, [Fd]), - {term, T}= get_term(P), + {term, T} = get_term(P), T. send_command(P, Name, Args) -> runner:send_term(P, {Name,list_to_tuple(Args)}). - - - - diff --git a/lib/erl_interface/test/ei_connect_SUITE.erl b/lib/erl_interface/test/ei_connect_SUITE.erl index c94ac37af4..1ef2525251 100644 --- a/lib/erl_interface/test/ei_connect_SUITE.erl +++ b/lib/erl_interface/test/ei_connect_SUITE.erl @@ -24,173 +24,145 @@ -include_lib("common_test/include/ct.hrl"). -include("ei_connect_SUITE_data/ei_connect_test_cases.hrl"). --export([ - all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - init_per_testcase/2, - end_per_testcase/2, - - ei_send/1, - ei_reg_send/1, - ei_format_pid/1, - ei_rpc/1, - rpc_test/1, - ei_send_funs/1, - ei_threaded_send/1, - ei_set_get_tracelevel/1 - ]). +-export([all/0, suite/0, + ei_send/1, + ei_reg_send/1, + ei_format_pid/1, + ei_rpc/1, + rpc_test/1, + ei_send_funs/1, + ei_threaded_send/1, + ei_set_get_tracelevel/1]). -import(runner, [get_term/1,send_term/2]). -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}, + {timetrap, {seconds, 30}}]. all() -> [ei_send, ei_reg_send, ei_rpc, ei_format_pid, ei_send_funs, ei_threaded_send, ei_set_get_tracelevel]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - -init_per_testcase(_Case, Config) -> - Dog = ?t:timetrap(?t:minutes(0.25)), - [{watchdog, Dog}|Config]. - -end_per_testcase(_Case, Config) -> - Dog = ?config(watchdog, Config), - test_server:timetrap_cancel(Dog), - ok. - ei_send(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), - ?line {ok,Fd} = ei_connect(P, node()), + P = runner:start(?interpret), + 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), + {ok,Fd} = ei_connect(P, node()), - ?line ok = ei_send(P, Fd, self(), AMsg={a,message}), - ?line receive AMsg -> ok end, + ok = ei_send(P, Fd, self(), AMsg={a,message}), + receive AMsg -> ok end, - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + runner:send_eot(P), + runner:recv_eot(P), ok. ei_format_pid(Config) when is_list(Config) -> - ?line S = self(), - ?line P = runner:start(?interpret), - ?line 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), - ?line {ok,Fd} = ei_connect(P, node()), + S = self(), + P = runner:start(?interpret), + 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), + {ok,Fd} = ei_connect(P, node()), - ?line ok = ei_format_pid(P, Fd, S), - ?line receive S -> ok end, + ok = ei_format_pid(P, Fd, S), + receive S -> ok end, - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + runner:send_eot(P), + runner:recv_eot(P), ok. ei_send_funs(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), - ?line {ok,Fd} = ei_connect(P, node()), - - ?line Fun1 = fun ei_send/1, - ?line Fun2 = fun(X) -> P, X, Fd, Fun1 end, - - ?line AMsg={Fun1,Fun2}, + P = runner:start(?interpret), + 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), + {ok,Fd} = ei_connect(P, node()), + + Fun1 = fun ei_send/1, + Fun2 = fun(X) -> P, X, Fd, Fun1 end, + + AMsg={Fun1,Fun2}, %%AMsg={wait_with_funs, new_dist_format}, - ?line ok = ei_send_funs(P, Fd, self(), AMsg), - ?line EIMsg = receive M -> M end, - ?line EIMsg = AMsg, + ok = ei_send_funs(P, Fd, self(), AMsg), + EIMsg = receive M -> M end, + EIMsg = AMsg, - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + runner:send_eot(P), + runner:recv_eot(P), ok. ei_reg_send(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), - ?line {ok,Fd} = ei_connect(P, node()), + P = runner:start(?interpret), + 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), + {ok,Fd} = ei_connect(P, node()), ARegName = a_strange_registred_name, - ?line register(ARegName, self()), - ?line ok = ei_reg_send(P, Fd, ARegName, AMsg={another,[strange],message}), - ?line receive AMsg -> ok end, + register(ARegName, self()), + ok = ei_reg_send(P, Fd, ARegName, AMsg={another,[strange],message}), + receive AMsg -> ok end, - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + runner:send_eot(P), + runner:recv_eot(P), ok. ei_threaded_send(Config) when is_list(Config) -> - ?line Einode = filename:join(?config(data_dir, Config), "einode"), - ?line N = 15, - ?line Host = atom_to_list(node()), - ?line TestServerPid = self(), - ?line [ spawn_link(fun() -> rec_einode(I, TestServerPid) end) - || I <- lists:seq(0, N-1) ], - ?line [ receive {I,registered} -> ok end - || I <- lists:seq(0, N-1) ], - ?line spawn_link(fun() -> start_einode(Einode, N, Host) end), - ?line [ receive I -> ok end - || I <- lists:seq(0, N-1) ], + Einode = filename:join(proplists:get_value(data_dir, Config), "einode"), + N = 15, + Host = atom_to_list(node()), + TestServerPid = self(), + [ spawn_link(fun() -> rec_einode(I, TestServerPid) end) + || I <- lists:seq(0, N-1) ], + [ receive {I,registered} -> ok end + || I <- lists:seq(0, N-1) ], + spawn_link(fun() -> start_einode(Einode, N, Host) end), + [ receive I -> ok end + || I <- lists:seq(0, N-1) ], ok. rec_einode(N, TestServerPid) -> - ?line Regname = list_to_atom("mth"++integer_to_list(N)), - ?line register(Regname, self()), - ?line TestServerPid ! {N, registered}, - ?line io:format("~p waiting~n", [Regname]), - ?line receive - X -> - ?line io:format("Received by ~s ~p~n", [Regname, X]), - ?line TestServerPid ! N, - ?line X - after 10000 -> - ?line test_server:fail(Regname) - end. + Regname = list_to_atom("mth"++integer_to_list(N)), + register(Regname, self()), + TestServerPid ! {N, registered}, + io:format("~p waiting~n", [Regname]), + receive + X -> + io:format("Received by ~s ~p~n", [Regname, X]), + TestServerPid ! N, + X + after 10000 -> + ct:fail(Regname) + end. start_einode(Einode, N, Host) -> Einodecmd = Einode ++ " " ++ atom_to_list(erlang:get_cookie()) - ++ " " ++ integer_to_list(N) ++ " " ++ Host, + ++ " " ++ integer_to_list(N) ++ " " ++ Host, io:format("Einodecmd ~p ~n", [Einodecmd]), - ?line open_port({spawn, Einodecmd}, []), + open_port({spawn, Einodecmd}, []), ok. ei_rpc(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), - ?line {ok,Fd} = ei_connect(P, node()), + P = runner:start(?interpret), + 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), + {ok,Fd} = ei_connect(P, node()), - ?line S= "Hej du glade!", SRev = lists:reverse(S), - ?line X = ei_rpc(P, Fd, self(), {?MODULE, rpc_test}, [SRev]), - ?line {term, S}= X, + S= "Hej du glade!", SRev = lists:reverse(S), + X = ei_rpc(P, Fd, self(), {?MODULE, rpc_test}, [SRev]), + {term, S}= X, - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + runner:send_eot(P), + runner:recv_eot(P), ok. ei_set_get_tracelevel(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line 5 = ei_set_get_tracelevel(P, 5), - ?line 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), - ?line {ok,Fd} = ei_connect(P, node()), + P = runner:start(?interpret), + 5 = ei_set_get_tracelevel(P, 5), + 0 = ei_connect_init(P, 42, erlang:get_cookie(), 0), + {ok,Fd} = ei_connect(P, node()), - ?line S= "Hej du glade!", SRev = lists:reverse(S), - ?line X = ei_rpc(P, Fd, self(), {?MODULE, rpc_test}, [SRev]), - ?line {term, S}= X, + S= "Hej du glade!", SRev = lists:reverse(S), + X = ei_rpc(P, Fd, self(), {?MODULE, rpc_test}, [SRev]), + {term, S}= X, - ?line 0 = ei_set_get_tracelevel(P, 0), + 0 = ei_set_get_tracelevel(P, 0), - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + runner:send_eot(P), + runner:recv_eot(P), ok. @@ -199,20 +171,20 @@ ei_set_get_tracelevel(Config) when is_list(Config) -> ei_connect_init(P, Num, Cookie, Creation) -> send_command(P, ei_connect_init, [Num,Cookie,Creation]), case get_term(P) of - {term,Int} when is_integer(Int) -> Int + {term,Int} when is_integer(Int) -> Int end. ei_connect(P, Node) -> send_command(P, ei_connect, [Node]), case get_term(P) of - {term,{Fd,_}} when Fd >= 0 -> {ok,Fd}; - {term,{-1,Errno}} -> {error,Errno} + {term,{Fd,_}} when Fd >= 0 -> {ok,Fd}; + {term,{-1,Errno}} -> {error,Errno} end. ei_set_get_tracelevel(P, Tracelevel) -> send_command(P, ei_set_get_tracelevel, [Tracelevel]), case get_term(P) of - {term,{tracelevel, Level}} when is_integer(Level) -> Level + {term,{tracelevel, Level}} when is_integer(Level) -> Level end. ei_send(P, Fd, To, Msg) -> @@ -238,12 +210,12 @@ ei_rpc(P, Fd, To, Func, Msg) -> get_send_result(P) -> case get_term(P) of - {term,{0,_}} -> ok; - {term,{1,_}} -> ok; - {term,{-1,Errno}} -> {error,Errno}; - {term,{Res,Errno}}-> - io:format("Return value: ~p\nerl_errno: ~p", [Res,Errno]), - ?t:fail(bad_return_value) + {term,{0,_}} -> ok; + {term,{1,_}} -> ok; + {term,{-1,Errno}} -> {error,Errno}; + {term,{Res,Errno}}-> + io:format("Return value: ~p\nerl_errno: ~p", [Res,Errno]), + ct:fail(bad_return_value) end. send_command(P, Name, Args) -> diff --git a/lib/erl_interface/test/ei_decode_SUITE.erl b/lib/erl_interface/test/ei_decode_SUITE.erl index 91357c99f2..b6cbda0817 100644 --- a/lib/erl_interface/test/ei_decode_SUITE.erl +++ b/lib/erl_interface/test/ei_decode_SUITE.erl @@ -24,20 +24,15 @@ -include_lib("common_test/include/ct.hrl"). -include("ei_decode_SUITE_data/ei_decode_test_cases.hrl"). --export( - [ - all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, init_per_testcase/2, - end_per_testcase/2, - test_ei_decode_long/1, - test_ei_decode_ulong/1, - test_ei_decode_longlong/1, - test_ei_decode_ulonglong/1, - test_ei_decode_char/1, - test_ei_decode_nonoptimal/1, - test_ei_decode_misc/1, - test_ei_decode_utf8_atom/1 - ]). +-export([all/0, suite/0, + test_ei_decode_long/1, + test_ei_decode_ulong/1, + test_ei_decode_longlong/1, + test_ei_decode_ulonglong/1, + test_ei_decode_char/1, + test_ei_decode_nonoptimal/1, + test_ei_decode_misc/1, + test_ei_decode_utf8_atom/1]). suite() -> [{ct_hooks,[ts_install_cth]}]. @@ -47,27 +42,6 @@ all() -> test_ei_decode_char, test_ei_decode_nonoptimal, test_ei_decode_misc, test_ei_decode_utf8_atom]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - -init_per_testcase(_TC, Config) -> - Config. - -end_per_testcase(_RC, Config) -> - Config. - %% --------------------------------------------------------------------------- % NOTE: for historical reasons we don't pach as tight as we can, @@ -76,55 +50,51 @@ end_per_testcase(_RC, Config) -> %% ######################################################################## %% -test_ei_decode_long(suite) -> []; test_ei_decode_long(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_decode_long), + P = runner:start(?test_ei_decode_long), send_integers(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% ######################################################################## %% -test_ei_decode_ulong(suite) -> []; test_ei_decode_ulong(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_decode_ulong), + P = runner:start(?test_ei_decode_ulong), send_integers(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. % (*) In practical terms, other values may fit into the ext format % i32 is signed 32 bit on C side % u32 is unsigned 32 bit on C side - + %% ######################################################################## %% -test_ei_decode_longlong(suite) -> []; test_ei_decode_longlong(Config) when is_list(Config) -> case os:type() of - vxworks -> - {skip,"Skipped on VxWorks"}; - _ -> - ?line P = runner:start(?test_ei_decode_longlong), - send_integers2(P), - ?line runner:recv_eot(P), - ok + vxworks -> + {skip,"Skipped on VxWorks"}; + _ -> + P = runner:start(?test_ei_decode_longlong), + send_integers2(P), + runner:recv_eot(P), + ok end. %% ######################################################################## %% -test_ei_decode_ulonglong(suite) -> []; test_ei_decode_ulonglong(Config) when is_list(Config) -> case os:type() of - vxworks -> - {skip,"Skipped on VxWorks"}; - _ -> - ?line P = runner:start(?test_ei_decode_ulonglong), - send_integers2(P), - ?line runner:recv_eot(P), - ok + vxworks -> + {skip,"Skipped on VxWorks"}; + _ -> + P = runner:start(?test_ei_decode_ulonglong), + send_integers2(P), + runner:recv_eot(P), + ok end. @@ -133,38 +103,36 @@ test_ei_decode_ulonglong(Config) when is_list(Config) -> %% it is unsigned. %% FIXME maybe the API should change to use "unsigned char" to be clear?! -test_ei_decode_char(suite) -> []; test_ei_decode_char(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_decode_char), + P = runner:start(?test_ei_decode_char), - ?line send_term_as_binary(P,0), - ?line send_term_as_binary(P,16#7f), - ?line send_term_as_binary(P,16#ff), + send_term_as_binary(P,0), + send_term_as_binary(P,16#7f), + send_term_as_binary(P,16#ff), - ?line send_term_as_binary(P, []), % illegal type + send_term_as_binary(P, []), % illegal type - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% ######################################################################## %% -test_ei_decode_nonoptimal(suite) -> []; test_ei_decode_nonoptimal(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_decode_nonoptimal), + P = runner:start(?test_ei_decode_nonoptimal), send_non_optimal_pos(P), % decode_char send_non_optimal(P), % decode_long send_non_optimal_pos(P), % decode_ulong case os:type() of - vxworks -> - ok; - _ -> - send_non_optimal(P), % decode_longlong - send_non_optimal_pos(P) % decode_ulonglong + vxworks -> + ok; + _ -> + send_non_optimal(P), % decode_longlong + send_non_optimal_pos(P) % decode_ulonglong end, - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. @@ -173,82 +141,81 @@ send_non_optimal(P) -> send_non_optimal_neg(P). send_non_optimal_pos(P) -> - ?line send_raw(P, <<131,97,42>>), - ?line send_raw(P, <<131,98,42:32>>), - ?line send_raw(P, <<131,110,1,0,42>>), - ?line send_raw(P, <<131,110,2,0,42,0>>), - ?line send_raw(P, <<131,110,4,0,42,0,0,0>>), - ?line send_raw(P, <<131,111,0,0,0,1,0,42>>), - ?line send_raw(P, <<131,111,0,0,0,2,0,42,0>>), - ?line send_raw(P, <<131,111,0,0,0,3,0,42,0,0>>), - ?line send_raw(P, <<131,111,0,0,0,6,0,42,0,0,0,0,0>>), + send_raw(P, <<131,97,42>>), + send_raw(P, <<131,98,42:32>>), + send_raw(P, <<131,110,1,0,42>>), + send_raw(P, <<131,110,2,0,42,0>>), + send_raw(P, <<131,110,4,0,42,0,0,0>>), + send_raw(P, <<131,111,0,0,0,1,0,42>>), + send_raw(P, <<131,111,0,0,0,2,0,42,0>>), + send_raw(P, <<131,111,0,0,0,3,0,42,0,0>>), + send_raw(P, <<131,111,0,0,0,6,0,42,0,0,0,0,0>>), ok. send_non_optimal_neg(P) -> -% ?line send_raw(P, <<131,97,-42>>), - ?line send_raw(P, <<131,98,-42:32>>), - ?line send_raw(P, <<131,110,1,1,42>>), - ?line send_raw(P, <<131,110,2,1,42,0>>), - ?line send_raw(P, <<131,110,4,1,42,0,0,0>>), - ?line send_raw(P, <<131,111,0,0,0,1,1,42>>), - ?line send_raw(P, <<131,111,0,0,0,2,1,42,0>>), - ?line send_raw(P, <<131,111,0,0,0,3,1,42,0,0>>), - ?line send_raw(P, <<131,111,0,0,0,6,1,42,0,0,0,0,0>>), + % send_raw(P, <<131,97,-42>>), + send_raw(P, <<131,98,-42:32>>), + send_raw(P, <<131,110,1,1,42>>), + send_raw(P, <<131,110,2,1,42,0>>), + send_raw(P, <<131,110,4,1,42,0,0,0>>), + send_raw(P, <<131,111,0,0,0,1,1,42>>), + send_raw(P, <<131,111,0,0,0,2,1,42,0>>), + send_raw(P, <<131,111,0,0,0,3,1,42,0,0>>), + send_raw(P, <<131,111,0,0,0,6,1,42,0,0,0,0,0>>), ok. %% ######################################################################## %% -test_ei_decode_misc(suite) -> []; test_ei_decode_misc(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_decode_misc), + P = runner:start(?test_ei_decode_misc), - ?line send_term_as_binary(P,0.0), - ?line send_term_as_binary(P,-1.0), - ?line send_term_as_binary(P,1.0), + send_term_as_binary(P,0.0), + send_term_as_binary(P,-1.0), + send_term_as_binary(P,1.0), - ?line send_term_as_binary(P,false), - ?line send_term_as_binary(P,true), + send_term_as_binary(P,false), + send_term_as_binary(P,true), - ?line send_term_as_binary(P,foo), - ?line send_term_as_binary(P,''), - ?line send_term_as_binary(P,'ÅÄÖåäö'), + send_term_as_binary(P,foo), + send_term_as_binary(P,''), + send_term_as_binary(P,'ÅÄÖåäö'), - ?line send_term_as_binary(P,"foo"), - ?line send_term_as_binary(P,""), - ?line send_term_as_binary(P,"ÅÄÖåäö"), + send_term_as_binary(P,"foo"), + send_term_as_binary(P,""), + send_term_as_binary(P,"ÅÄÖåäö"), - ?line send_term_as_binary(P,<<"foo">>), - ?line send_term_as_binary(P,<<>>), - ?line send_term_as_binary(P,<<"ÅÄÖåäö">>), + send_term_as_binary(P,<<"foo">>), + send_term_as_binary(P,<<>>), + send_term_as_binary(P,<<"ÅÄÖåäö">>), -% ?line send_term_as_binary(P,{}), -% ?line send_term_as_binary(P,[]), + % send_term_as_binary(P,{}), + % send_term_as_binary(P,[]), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% ######################################################################## %% test_ei_decode_utf8_atom(Config) -> - ?line P = runner:start(?test_ei_decode_utf8_atom), + P = runner:start(?test_ei_decode_utf8_atom), send_utf8_atom_as_binary(P,"Ã¥"), send_utf8_atom_as_binary(P,"ä"), send_term_as_binary(P,'ö'), send_term_as_binary(P,'õ'), - - ?line send_utf8_atom_as_binary(P,[1758]), - ?line send_utf8_atom_as_binary(P,[1758,1758]), - ?line send_utf8_atom_as_binary(P,[1758,1758,1758]), - ?line send_utf8_atom_as_binary(P,[1758,1758,1758,1758]), + + send_utf8_atom_as_binary(P,[1758]), + send_utf8_atom_as_binary(P,[1758,1758]), + send_utf8_atom_as_binary(P,[1758,1758,1758]), + send_utf8_atom_as_binary(P,[1758,1758,1758,1758]), send_utf8_atom_as_binary(P,"a"), send_utf8_atom_as_binary(P,"b"), send_term_as_binary(P,'c'), send_term_as_binary(P,'d'), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. @@ -264,77 +231,77 @@ send_utf8_atom_as_binary(Port, String) -> Port ! {self(), {command, term_to_binary(uc_atup(String))}}. send_integers(P) -> - ?line send_term_as_binary(P,0), % SMALL_INTEGER_EXT smallest - ?line send_term_as_binary(P,255), % SMALL_INTEGER_EXT largest - ?line send_term_as_binary(P,256), % INTEGER_EXT smallest pos (*) - ?line send_term_as_binary(P,-1), % INTEGER_EXT largest neg - - ?line send_term_as_binary(P, 16#07ffffff), % INTEGER_EXT old largest (28 bits) - ?line send_term_as_binary(P,-16#08000000), % INTEGER_EXT old smallest - ?line send_term_as_binary(P, 16#08000000), % SMALL_BIG_EXT old smallest pos(*) - ?line send_term_as_binary(P,-16#08000001), % SMALL_BIG_EXT old largest neg (*) - - ?line send_term_as_binary(P, 16#7fffffff), % INTEGER_EXT new largest (32 bits) - ?line send_term_as_binary(P,-16#80000000), % INTEGER_EXT new smallest (32 bis) - ?line send_term_as_binary(P, 16#80000000), % SMALL_BIG_EXT new smallest pos(*) - ?line send_term_as_binary(P,-16#80000001), % SMALL_BIG_EXT new largest neg (*) - + send_term_as_binary(P,0), % SMALL_INTEGER_EXT smallest + send_term_as_binary(P,255), % SMALL_INTEGER_EXT largest + send_term_as_binary(P,256), % INTEGER_EXT smallest pos (*) + send_term_as_binary(P,-1), % INTEGER_EXT largest neg + + send_term_as_binary(P, 16#07ffffff), % INTEGER_EXT old largest (28 bits) + send_term_as_binary(P,-16#08000000), % INTEGER_EXT old smallest + send_term_as_binary(P, 16#08000000), % SMALL_BIG_EXT old smallest pos(*) + send_term_as_binary(P,-16#08000001), % SMALL_BIG_EXT old largest neg (*) + + send_term_as_binary(P, 16#7fffffff), % INTEGER_EXT new largest (32 bits) + send_term_as_binary(P,-16#80000000), % INTEGER_EXT new smallest (32 bis) + send_term_as_binary(P, 16#80000000), % SMALL_BIG_EXT new smallest pos(*) + send_term_as_binary(P,-16#80000001), % SMALL_BIG_EXT new largest neg (*) + case erlang:system_info({wordsize,external}) of - 4 -> - ?line send_term_as_binary(P, 16#80000000),% SMALL_BIG_EXT u32 - ?line send_term_as_binary(P, 16#ffffffff),% SMALL_BIG_EXT largest u32 - - ?line send_term_as_binary(P, 16#7fffffffffff), % largest i48 - ?line send_term_as_binary(P,-16#800000000000), % smallest i48 - ?line send_term_as_binary(P, 16#ffffffffffff), % largest u48 - ?line send_term_as_binary(P, 16#7fffffffffffffff), % largest i64 - ?line send_term_as_binary(P,-16#8000000000000000), % smallest i64 - ?line send_term_as_binary(P, 16#ffffffffffffffff); % largest u64 - 8 -> - ?line send_term_as_binary(P, 16#8000000000000000),% SMALL_BIG_EXT u64 - % SMALL_BIG_EXT largest u64 - ?line send_term_as_binary(P, 16#ffffffffffffffff), - % largest i96 - ?line send_term_as_binary(P, 16#7fffffffffffffffffffffff), - % smallest i96 - ?line send_term_as_binary(P,-16#800000000000000000000000), - % largest u96 - ?line send_term_as_binary(P, 16#ffffffffffffffffffffffff), - % largest i128 - ?line send_term_as_binary(P, 16#7fffffffffffffffffffffffffffffff), - % smallest i128 - ?line send_term_as_binary(P,-16#80000000000000000000000000000000), - % largest u128 - ?line send_term_as_binary(P, 16#ffffffffffffffffffffffffffffffff) + 4 -> + send_term_as_binary(P, 16#80000000),% SMALL_BIG_EXT u32 + send_term_as_binary(P, 16#ffffffff),% SMALL_BIG_EXT largest u32 + + send_term_as_binary(P, 16#7fffffffffff), % largest i48 + send_term_as_binary(P,-16#800000000000), % smallest i48 + send_term_as_binary(P, 16#ffffffffffff), % largest u48 + send_term_as_binary(P, 16#7fffffffffffffff), % largest i64 + send_term_as_binary(P,-16#8000000000000000), % smallest i64 + send_term_as_binary(P, 16#ffffffffffffffff); % largest u64 + 8 -> + send_term_as_binary(P, 16#8000000000000000),% SMALL_BIG_EXT u64 + % SMALL_BIG_EXT largest u64 + send_term_as_binary(P, 16#ffffffffffffffff), + % largest i96 + send_term_as_binary(P, 16#7fffffffffffffffffffffff), + % smallest i96 + send_term_as_binary(P,-16#800000000000000000000000), + % largest u96 + send_term_as_binary(P, 16#ffffffffffffffffffffffff), + % largest i128 + send_term_as_binary(P, 16#7fffffffffffffffffffffffffffffff), + % smallest i128 + send_term_as_binary(P,-16#80000000000000000000000000000000), + % largest u128 + send_term_as_binary(P, 16#ffffffffffffffffffffffffffffffff) end, - ?line send_term_as_binary(P, []), % illegal type + send_term_as_binary(P, []), % illegal type ok. send_integers2(P) -> - ?line send_term_as_binary(P,0), % SMALL_INTEGER_EXT smallest - ?line send_term_as_binary(P,255), % SMALL_INTEGER_EXT largest - ?line send_term_as_binary(P,256), % INTEGER_EXT smallest pos (*) - ?line send_term_as_binary(P,-1), % INTEGER_EXT largest neg - - ?line send_term_as_binary(P, 16#07ffffff), % INTEGER_EXT old largest (28 bits) - ?line send_term_as_binary(P,-16#08000000), % INTEGER_EXT old smallest - ?line send_term_as_binary(P, 16#08000000), % SMALL_BIG_EXT old smallest pos(*) - ?line send_term_as_binary(P,-16#08000001), % SMALL_BIG_EXT old largest neg (*) - - ?line send_term_as_binary(P, 16#7fffffff), % INTEGER_EXT new largest (32 bits) - ?line send_term_as_binary(P,-16#80000000), % INTEGER_EXT new smallest - ?line send_term_as_binary(P, 16#80000000), % SMALL_BIG_EXT new smallest pos(*) - ?line send_term_as_binary(P,-16#80000001), % SMALL_BIG_EXT new largest neg (*) - - ?line send_term_as_binary(P, 16#ffffffff),% SMALL_BIG_EXT largest u32 - - ?line send_term_as_binary(P, 16#7fffffffffff), % largest i48 - ?line send_term_as_binary(P,-16#800000000000), % smallest i48 - ?line send_term_as_binary(P, 16#ffffffffffff), % largest u48 - ?line send_term_as_binary(P, 16#7fffffffffffffff), % largest i64 - ?line send_term_as_binary(P,-16#8000000000000000), % smallest i64 - ?line send_term_as_binary(P, 16#ffffffffffffffff), % largest u64 - ?line send_term_as_binary(P, []), % illegal type + send_term_as_binary(P,0), % SMALL_INTEGER_EXT smallest + send_term_as_binary(P,255), % SMALL_INTEGER_EXT largest + send_term_as_binary(P,256), % INTEGER_EXT smallest pos (*) + send_term_as_binary(P,-1), % INTEGER_EXT largest neg + + send_term_as_binary(P, 16#07ffffff), % INTEGER_EXT old largest (28 bits) + send_term_as_binary(P,-16#08000000), % INTEGER_EXT old smallest + send_term_as_binary(P, 16#08000000), % SMALL_BIG_EXT old smallest pos(*) + send_term_as_binary(P,-16#08000001), % SMALL_BIG_EXT old largest neg (*) + + send_term_as_binary(P, 16#7fffffff), % INTEGER_EXT new largest (32 bits) + send_term_as_binary(P,-16#80000000), % INTEGER_EXT new smallest + send_term_as_binary(P, 16#80000000), % SMALL_BIG_EXT new smallest pos(*) + send_term_as_binary(P,-16#80000001), % SMALL_BIG_EXT new largest neg (*) + + send_term_as_binary(P, 16#ffffffff), % SMALL_BIG_EXT largest u32 + + send_term_as_binary(P, 16#7fffffffffff), % largest i48 + send_term_as_binary(P,-16#800000000000), % smallest i48 + send_term_as_binary(P, 16#ffffffffffff), % largest u48 + send_term_as_binary(P, 16#7fffffffffffffff), % largest i64 + send_term_as_binary(P,-16#8000000000000000), % smallest i64 + send_term_as_binary(P, 16#ffffffffffffffff), % largest u64 + send_term_as_binary(P, []), % illegal type ok. uc_atup(ATxt) -> @@ -344,35 +311,32 @@ string_to_atom(String) -> Utf8List = string_to_utf8_list(String), Len = length(Utf8List), TagLen = case Len < 256 of - true -> [119, Len]; - false -> [118, Len bsr 8, Len band 16#ff] - end, + true -> [119, Len]; + false -> [118, Len bsr 8, Len band 16#ff] + end, binary_to_term(list_to_binary([131, TagLen, Utf8List])). string_to_utf8_list([]) -> []; string_to_utf8_list([CP|CPs]) when is_integer(CP), - 0 =< CP, - CP =< 16#7F -> + 0 =< CP, + CP =< 16#7F -> [CP | string_to_utf8_list(CPs)]; string_to_utf8_list([CP|CPs]) when is_integer(CP), - 16#80 =< CP, - CP =< 16#7FF -> + 16#80 =< CP, + CP =< 16#7FF -> [16#C0 bor (CP bsr 6), - 16#80 bor (16#3F band CP) - | string_to_utf8_list(CPs)]; + 16#80 bor (16#3F band CP) | string_to_utf8_list(CPs)]; string_to_utf8_list([CP|CPs]) when is_integer(CP), - 16#800 =< CP, - CP =< 16#FFFF -> + 16#800 =< CP, + CP =< 16#FFFF -> [16#E0 bor (CP bsr 12), 16#80 bor (16#3F band (CP bsr 6)), - 16#80 bor (16#3F band CP) - | string_to_utf8_list(CPs)]; + 16#80 bor (16#3F band CP) | string_to_utf8_list(CPs)]; string_to_utf8_list([CP|CPs]) when is_integer(CP), - 16#10000 =< CP, - CP =< 16#10FFFF -> + 16#10000 =< CP, + CP =< 16#10FFFF -> [16#F0 bor (CP bsr 18), 16#80 bor (16#3F band (CP bsr 12)), 16#80 bor (16#3F band (CP bsr 6)), - 16#80 bor (16#3F band CP) - | string_to_utf8_list(CPs)]. + 16#80 bor (16#3F band CP) | string_to_utf8_list(CPs)]. diff --git a/lib/erl_interface/test/ei_decode_encode_SUITE.erl b/lib/erl_interface/test/ei_decode_encode_SUITE.erl index 6a25b98209..a3d0ca0576 100644 --- a/lib/erl_interface/test/ei_decode_encode_SUITE.erl +++ b/lib/erl_interface/test/ei_decode_encode_SUITE.erl @@ -24,34 +24,15 @@ -include_lib("common_test/include/ct.hrl"). -include("ei_decode_encode_SUITE_data/ei_decode_encode_test_cases.hrl"). --export( - [ - all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - test_ei_decode_encode/1 - ]). +-export([all/0, suite/0, + test_ei_decode_encode/1]). -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}]. all() -> [test_ei_decode_encode]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - - %% --------------------------------------------------------------------------- % NOTE: these types have no meaning on the C side so we pass them @@ -60,20 +41,19 @@ end_per_group(_GroupName, Config) -> %% ######################################################################## %% -test_ei_decode_encode(suite) -> []; test_ei_decode_encode(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_decode_encode), + P = runner:start(?test_ei_decode_encode), Fun = fun (X) -> {X,true} end, Pid = self(), Port = case os:type() of - {win32,_} -> - open_port({spawn,"sort"},[]); - {unix, darwin} -> - open_port({spawn,"/usr/bin/true"},[]); - _ -> - open_port({spawn,"/bin/true"},[]) - end, + {win32,_} -> + open_port({spawn,"sort"},[]); + {unix, darwin} -> + open_port({spawn,"/usr/bin/true"},[]); + _ -> + open_port({spawn,"/bin/true"},[]) + end, Ref = make_ref(), Trace = {1,2,3,self(),4}, % FIXME how to construct?! @@ -86,47 +66,47 @@ test_ei_decode_encode(Config) when is_list(Config) -> BigLargeB = 1 bsl 11112 + BigSmallB, BigLargeC = BigSmallA * BigSmallB * BigSmallC * BigSmallA, - ?line send_rec(P, Fun), - ?line send_rec(P, Pid), - ?line send_rec(P, Port), - ?line send_rec(P, Ref), - ?line send_rec(P, Trace), + send_rec(P, Fun), + send_rec(P, Pid), + send_rec(P, Port), + send_rec(P, Ref), + send_rec(P, Trace), % bigs - ?line send_rec(P, BigSmallA), - ?line send_rec(P, BigSmallB), - ?line send_rec(P, BigSmallC), - - ?line send_rec(P, BigLargeA), - ?line send_rec(P, BigLargeB), - ?line send_rec(P, BigLargeC), + send_rec(P, BigSmallA), + send_rec(P, BigSmallB), + send_rec(P, BigSmallC), + + send_rec(P, BigLargeA), + send_rec(P, BigLargeB), + send_rec(P, BigLargeC), %% Test large node containers... - ?line ThisNode = {node(), erlang:system_info(creation)}, - ?line TXPid = mk_pid(ThisNode, 32767, 8191), - ?line TXPort = mk_port(ThisNode, 268435455), - ?line TXRef = mk_ref(ThisNode, [262143, 4294967295, 4294967295]), + ThisNode = {node(), erlang:system_info(creation)}, + TXPid = mk_pid(ThisNode, 32767, 8191), + TXPort = mk_port(ThisNode, 268435455), + TXRef = mk_ref(ThisNode, [262143, 4294967295, 4294967295]), - ?line OtherNode = {gurka@sallad, 2}, - ?line OXPid = mk_pid(OtherNode, 32767, 8191), - ?line OXPort = mk_port(OtherNode, 268435455), - ?line OXRef = mk_ref(OtherNode, [262143, 4294967295, 4294967295]), + OtherNode = {gurka@sallad, 2}, + OXPid = mk_pid(OtherNode, 32767, 8191), + OXPort = mk_port(OtherNode, 268435455), + OXRef = mk_ref(OtherNode, [262143, 4294967295, 4294967295]), - ?line send_rec(P, TXPid), - ?line send_rec(P, TXPort), - ?line send_rec(P, TXRef), - ?line send_rec(P, OXPid), - ?line send_rec(P, OXPort), - ?line send_rec(P, OXRef), + send_rec(P, TXPid), + send_rec(P, TXPort), + send_rec(P, TXRef), + send_rec(P, OXPid), + send_rec(P, OXPort), + send_rec(P, OXRef), %% Unicode atoms [begin send_rec(P, Atom), - send_rec(P, mk_pid({Atom,1}, 23434, 3434)), - send_rec(P, mk_port({Atom,1}, 2343434)), - send_rec(P, mk_ref({Atom,1}, [262143, 8723648, 24097245])), - void + send_rec(P, mk_pid({Atom,1}, 23434, 3434)), + send_rec(P, mk_port({Atom,1}, 2343434)), + send_rec(P, mk_ref({Atom,1}, [262143, 8723648, 24097245])), + void end || Atom <- unicode_atom_data()], send_rec(P, {}), @@ -137,7 +117,7 @@ test_ei_decode_encode(Config) when is_list(Config) -> send_rec(P, #{key => value}), send_rec(P, maps:put(Port, Ref, #{key => value, key2 => Pid})), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. @@ -146,29 +126,27 @@ test_ei_decode_encode(Config) when is_list(Config) -> % We read two packets for each test, the ei_decode_encode and ei_x_decode_encode version.... send_rec(P, Term) when is_port(P) -> - %%?t:format("Testing: ~p~n", [Term]), P ! {self(), {command, term_to_binary(Term)}}, {_B,Term} = get_buf_and_term(P). - get_buf_and_term(P) -> B = get_binaries(P), case B of - <<131>> -> - io:format("(got single magic, no content)\n",[]), - {B,'$$magic$$'}; - <<131,_>> -> - T = binary_to_term(B), - io:format("~w\n~w\n(got magic)\n",[B,T]), - {B,T}; - _ -> - B1 = list_to_binary([131,B]), % No magic, add - T = binary_to_term(B1), - %io:format("~w\n~w\n(got no magic)\n",[B,T]), - {B,T} + <<131>> -> + io:format("(got single magic, no content)\n",[]), + {B,'$$magic$$'}; + <<131,_>> -> + T = binary_to_term(B), + io:format("~w\n~w\n(got magic)\n",[B,T]), + {B,T}; + _ -> + B1 = list_to_binary([131,B]), % No magic, add + T = binary_to_term(B1), + %io:format("~w\n~w\n(got no magic)\n",[B,T]), + {B,T} end. - + get_binaries(P) -> B1 = get_binary(P), @@ -177,40 +155,17 @@ get_binaries(P) -> get_binary(P) -> case runner:get_term(P) of - {bytes,L} -> - B = list_to_binary(L), - %%io:format("~w\n",[L]), -% For strange reasons <<131>> show up as <>.... -% io:format("~w\n",[B]), - B; - Other -> - Other + {bytes,L} -> + B = list_to_binary(L), + %%io:format("~w\n",[L]), + % For strange reasons <<131>> show up as <>.... + % io:format("~w\n",[B]), + B; + Other -> + Other end. %% - -% We use our own get_term() - -get_term(P) -> - case runner:get_term(P) of - {bytes,[131]} -> - io:format("(got single magic, no content)\n",[]), - '$$magic$$'; - {bytes,[131,L]} -> - B = list_to_binary(L), - T = binary_to_term(B), - io:format("~w\n~w\n(got magic)\n",[L,T]), - T; - {bytes,L} -> - B = list_to_binary([131,L]), - T = binary_to_term(B), - io:format("~w\n~w\n(got no magic)\n",[L,T]), - T; - Other -> - Other - end. - -%% %% Node container constructor functions %% @@ -249,17 +204,17 @@ mk_pid({NodeName, Creation}, Number, Serial) when is_atom(NodeName) -> mk_pid({NodeNameExt, Creation}, Number, Serial); mk_pid({NodeNameExt, Creation}, Number, Serial) -> case catch binary_to_term(list_to_binary([?VERSION_MAGIC, - ?PID_EXT, - NodeNameExt, - uint32_be(Number), - uint32_be(Serial), - uint8(Creation)])) of - Pid when is_pid(Pid) -> - Pid; - {'EXIT', {badarg, _}} -> - exit({badarg, mk_pid, [{NodeNameExt, Creation}, Number, Serial]}); - Other -> - exit({unexpected_binary_to_term_result, Other}) + ?PID_EXT, + NodeNameExt, + uint32_be(Number), + uint32_be(Serial), + uint8(Creation)])) of + Pid when is_pid(Pid) -> + Pid; + {'EXIT', {badarg, _}} -> + exit({badarg, mk_pid, [{NodeNameExt, Creation}, Number, Serial]}); + Other -> + exit({unexpected_binary_to_term_result, Other}) end. mk_port({NodeName, Creation}, Number) when is_atom(NodeName) -> @@ -267,56 +222,56 @@ mk_port({NodeName, Creation}, Number) when is_atom(NodeName) -> mk_port({NodeNameExt, Creation}, Number); mk_port({NodeNameExt, Creation}, Number) -> case catch binary_to_term(list_to_binary([?VERSION_MAGIC, - ?PORT_EXT, - NodeNameExt, - uint32_be(Number), - uint8(Creation)])) of - Port when is_port(Port) -> - Port; - {'EXIT', {badarg, _}} -> - exit({badarg, mk_port, [{NodeNameExt, Creation}, Number]}); - Other -> - exit({unexpected_binary_to_term_result, Other}) + ?PORT_EXT, + NodeNameExt, + uint32_be(Number), + uint8(Creation)])) of + Port when is_port(Port) -> + Port; + {'EXIT', {badarg, _}} -> + exit({badarg, mk_port, [{NodeNameExt, Creation}, Number]}); + Other -> + exit({unexpected_binary_to_term_result, Other}) end. mk_ref({NodeName, Creation}, Numbers) when is_atom(NodeName), - is_integer(Creation), - is_list(Numbers) -> + is_integer(Creation), + is_list(Numbers) -> <<?VERSION_MAGIC, NodeNameExt/binary>> = term_to_binary(NodeName), mk_ref({NodeNameExt, Creation}, Numbers); mk_ref({NodeNameExt, Creation}, [Number]) when is_binary(NodeNameExt), - is_integer(Creation), - is_integer(Number) -> + is_integer(Creation), + is_integer(Number) -> case catch binary_to_term(list_to_binary([?VERSION_MAGIC, - ?REFERENCE_EXT, - NodeNameExt, - uint32_be(Number), - uint8(Creation)])) of - Ref when is_reference(Ref) -> - Ref; - {'EXIT', {badarg, _}} -> - exit({badarg, mk_ref, [{NodeNameExt, Creation}, [Number]]}); - Other -> - exit({unexpected_binary_to_term_result, Other}) + ?REFERENCE_EXT, + NodeNameExt, + uint32_be(Number), + uint8(Creation)])) of + Ref when is_reference(Ref) -> + Ref; + {'EXIT', {badarg, _}} -> + exit({badarg, mk_ref, [{NodeNameExt, Creation}, [Number]]}); + Other -> + exit({unexpected_binary_to_term_result, Other}) end; mk_ref({NodeNameExt, Creation}, Numbers) when is_binary(NodeNameExt), - is_integer(Creation), - is_list(Numbers) -> + is_integer(Creation), + is_list(Numbers) -> case catch binary_to_term(list_to_binary([?VERSION_MAGIC, - ?NEW_REFERENCE_EXT, - uint16_be(length(Numbers)), - NodeNameExt, - uint8(Creation), - lists:map(fun (N) -> - uint32_be(N) - end, - Numbers)])) of - Ref when is_reference(Ref) -> - Ref; - {'EXIT', {badarg, _}} -> - exit({badarg, mk_ref, [{NodeNameExt, Creation}, Numbers]}); - Other -> - exit({unexpected_binary_to_term_result, Other}) + ?NEW_REFERENCE_EXT, + uint16_be(length(Numbers)), + NodeNameExt, + uint8(Creation), + lists:map(fun (N) -> + uint32_be(N) + end, + Numbers)])) of + Ref when is_reference(Ref) -> + Ref; + {'EXIT', {badarg, _}} -> + exit({badarg, mk_ref, [{NodeNameExt, Creation}, Numbers]}); + Other -> + exit({unexpected_binary_to_term_result, Other}) end. @@ -333,10 +288,10 @@ unicode_atom_data() -> uc_atup(lists:seq(65500, 65754)), uc_atup(lists:seq(65500, 65563)) | lists:map(fun (N) -> - Pow2 = (1 bsl N), - uc_atup(lists:seq(Pow2 - 127, Pow2 + 127)) - end, - lists:seq(7, 20)) + Pow2 = (1 bsl N), + uc_atup(lists:seq(Pow2 - 127, Pow2 + 127)) + end, + lists:seq(7, 20)) ]. uc_atup(ATxt) -> @@ -346,33 +301,33 @@ string_to_atom(String) -> Utf8List = string_to_utf8_list(String), Len = length(Utf8List), TagLen = case Len < 256 of - true -> [119, Len]; - false -> [118, Len bsr 8, Len band 16#ff] - end, + true -> [119, Len]; + false -> [118, Len bsr 8, Len band 16#ff] + end, binary_to_term(list_to_binary([131, TagLen, Utf8List])). string_to_utf8_list([]) -> []; string_to_utf8_list([CP|CPs]) when is_integer(CP), - 0 =< CP, - CP =< 16#7F -> + 0 =< CP, + CP =< 16#7F -> [CP | string_to_utf8_list(CPs)]; string_to_utf8_list([CP|CPs]) when is_integer(CP), - 16#80 =< CP, - CP =< 16#7FF -> + 16#80 =< CP, + CP =< 16#7FF -> [16#C0 bor (CP bsr 6), 16#80 bor (16#3F band CP) | string_to_utf8_list(CPs)]; string_to_utf8_list([CP|CPs]) when is_integer(CP), - 16#800 =< CP, - CP =< 16#FFFF -> + 16#800 =< CP, + CP =< 16#FFFF -> [16#E0 bor (CP bsr 12), 16#80 bor (16#3F band (CP bsr 6)), 16#80 bor (16#3F band CP) | string_to_utf8_list(CPs)]; string_to_utf8_list([CP|CPs]) when is_integer(CP), - 16#10000 =< CP, - CP =< 16#10FFFF -> + 16#10000 =< CP, + CP =< 16#10FFFF -> [16#F0 bor (CP bsr 18), 16#80 bor (16#3F band (CP bsr 12)), 16#80 bor (16#3F band (CP bsr 6)), diff --git a/lib/erl_interface/test/ei_encode_SUITE.erl b/lib/erl_interface/test/ei_encode_SUITE.erl index d94f3adf42..fab8367eed 100644 --- a/lib/erl_interface/test/ei_encode_SUITE.erl +++ b/lib/erl_interface/test/ei_encode_SUITE.erl @@ -24,22 +24,19 @@ -include_lib("common_test/include/ct.hrl"). -include("ei_encode_SUITE_data/ei_encode_test_cases.hrl"). --export( - [ - all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - test_ei_encode_long/1, - test_ei_encode_ulong/1, - test_ei_encode_longlong/1, - test_ei_encode_ulonglong/1, - test_ei_encode_char/1, - test_ei_encode_misc/1, - test_ei_encode_fails/1, - test_ei_encode_utf8_atom/1, - test_ei_encode_utf8_atom_len/1 - ]). - -suite() -> [{ct_hooks,[ts_install_cth]}]. +-export([all/0, suite/0, + test_ei_encode_long/1, + test_ei_encode_ulong/1, + test_ei_encode_longlong/1, + test_ei_encode_ulonglong/1, + test_ei_encode_char/1, + test_ei_encode_misc/1, + test_ei_encode_fails/1, + test_ei_encode_utf8_atom/1, + test_ei_encode_utf8_atom_len/1]). + +suite() -> + [{ct_hooks,[ts_install_cth]}]. all() -> [test_ei_encode_long, test_ei_encode_ulong, @@ -48,21 +45,6 @@ all() -> test_ei_encode_fails, test_ei_encode_utf8_atom, test_ei_encode_utf8_atom_len]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - %% --------------------------------------------------------------------------- @@ -72,105 +54,101 @@ end_per_group(_GroupName, Config) -> %% ######################################################################## %% -test_ei_encode_long(suite) -> []; test_ei_encode_long(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_encode_long), + P = runner:start(?test_ei_encode_long), - ?line {<<97,0>> ,0} = get_buf_and_term(P), - ?line {<<97,255>> ,255} = get_buf_and_term(P), - ?line {<<98,256:32/big-signed-integer>>,256} = get_buf_and_term(P), - ?line {<<98,-1:32/big-signed-integer>> ,-1} = get_buf_and_term(P), + {<<97,0>> ,0} = get_buf_and_term(P), + {<<97,255>> ,255} = get_buf_and_term(P), + {<<98,256:32/big-signed-integer>>,256} = get_buf_and_term(P), + {<<98,-1:32/big-signed-integer>> ,-1} = get_buf_and_term(P), - ?line {<<98, 16#07ffffff:32/big-signed-integer>>, 16#07ffffff} = get_buf_and_term(P), - ?line {<<98,-16#08000000:32/big-signed-integer>>,-16#08000000} = get_buf_and_term(P), - ?line {<<110,4,0, 0,0,0,8>> , 16#08000000} = get_buf_and_term(P), - ?line {<<110,4,1, 1,0,0,8>> ,-16#08000001} = get_buf_and_term(P), + {<<98, 16#07ffffff:32/big-signed-integer>>, 16#07ffffff} = get_buf_and_term(P), + {<<98,-16#08000000:32/big-signed-integer>>,-16#08000000} = get_buf_and_term(P), + {<<110,4,0, 0,0,0,8>> , 16#08000000} = get_buf_and_term(P), + {<<110,4,1, 1,0,0,8>> ,-16#08000001} = get_buf_and_term(P), - ?line {<<110,4,0, 255,255,255,127>> , 16#7fffffff} = get_buf_and_term(P), - ?line {<<110,4,1, 0,0,0,128>> ,-16#80000000} = get_buf_and_term(P), + {<<110,4,0, 255,255,255,127>> , 16#7fffffff} = get_buf_and_term(P), + {<<110,4,1, 0,0,0,128>> ,-16#80000000} = get_buf_and_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% ######################################################################## %% -test_ei_encode_ulong(suite) -> []; test_ei_encode_ulong(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_encode_ulong), + P = runner:start(?test_ei_encode_ulong), - ?line {<<97,0>> ,0} = get_buf_and_term(P), - ?line {<<97,255>> ,255} = get_buf_and_term(P), - ?line {<<98,256:32/big-unsigned-integer>>,256} = get_buf_and_term(P), + {<<97,0>> ,0} = get_buf_and_term(P), + {<<97,255>> ,255} = get_buf_and_term(P), + {<<98,256:32/big-unsigned-integer>>,256} = get_buf_and_term(P), - ?line {<<98, 16#07ffffff:32/big-signed-integer>>,16#07ffffff} = get_buf_and_term(P), - ?line {<<110,4,0, 0,0,0,8>> ,16#08000000} = get_buf_and_term(P), + {<<98, 16#07ffffff:32/big-signed-integer>>,16#07ffffff} = get_buf_and_term(P), + {<<110,4,0, 0,0,0,8>> ,16#08000000} = get_buf_and_term(P), - ?line {<<110,4,0, 255,255,255,127>> ,16#7fffffff} = get_buf_and_term(P), - ?line {<<110,4,0, 0,0,0,128>> ,16#80000000} = get_buf_and_term(P), - ?line {<<110,4,0, 255,255,255,255>> ,16#ffffffff} = get_buf_and_term(P), + {<<110,4,0, 255,255,255,127>> ,16#7fffffff} = get_buf_and_term(P), + {<<110,4,0, 0,0,0,128>> ,16#80000000} = get_buf_and_term(P), + {<<110,4,0, 255,255,255,255>> ,16#ffffffff} = get_buf_and_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% ######################################################################## %% -test_ei_encode_longlong(suite) -> []; test_ei_encode_longlong(Config) when is_list(Config) -> case os:type() of - vxworks -> - {skip,"Skipped on VxWorks"}; - _ -> - ?line P = runner:start(?test_ei_encode_longlong), - - ?line {<<97,0>> ,0} = get_buf_and_term(P), - ?line {<<97,255>> ,255} = get_buf_and_term(P), - ?line {<<98,256:32/big-signed-integer>>,256} = get_buf_and_term(P), - ?line {<<98,-1:32/big-signed-integer>> ,-1} = get_buf_and_term(P), - - ?line {<<98, 16#07ffffff:32/big-signed-integer>>, 16#07ffffff} = get_buf_and_term(P), - ?line {<<98,-16#08000000:32/big-signed-integer>>,-16#08000000} = get_buf_and_term(P), - ?line {<<110,4,0, 0,0,0,8>> , 16#08000000} = get_buf_and_term(P), - ?line {<<110,4,1, 1,0,0,8>> ,-16#08000001} = get_buf_and_term(P), - - ?line {<<110,4,0, 255,255,255,127>> , 16#7fffffff} = get_buf_and_term(P), - ?line {<<110,4,1, 0,0,0,128>> ,-16#80000000} = get_buf_and_term(P), - ?line {<<110,6,0, 255,255,255,255,255,127>> , 16#7fffffffffff} = get_buf_and_term(P), - ?line {<<110,6,1, 0,0,0,0,0,128>> ,-16#800000000000} = get_buf_and_term(P), - ?line {<<110,8,0, 255,255,255,255,255,255,255,127>>,16#7fffffffffffffff} = get_buf_and_term(P), - ?line {<<110,8,1, 0,0,0,0,0,0,0,128>> ,-16#8000000000000000} = get_buf_and_term(P), - - ?line runner:recv_eot(P), - ok + vxworks -> + {skip,"Skipped on VxWorks"}; + _ -> + P = runner:start(?test_ei_encode_longlong), + + {<<97,0>> ,0} = get_buf_and_term(P), + {<<97,255>> ,255} = get_buf_and_term(P), + {<<98,256:32/big-signed-integer>>,256} = get_buf_and_term(P), + {<<98,-1:32/big-signed-integer>> ,-1} = get_buf_and_term(P), + + {<<98, 16#07ffffff:32/big-signed-integer>>, 16#07ffffff} = get_buf_and_term(P), + {<<98,-16#08000000:32/big-signed-integer>>,-16#08000000} = get_buf_and_term(P), + {<<110,4,0, 0,0,0,8>> , 16#08000000} = get_buf_and_term(P), + {<<110,4,1, 1,0,0,8>> ,-16#08000001} = get_buf_and_term(P), + + {<<110,4,0, 255,255,255,127>> , 16#7fffffff} = get_buf_and_term(P), + {<<110,4,1, 0,0,0,128>> ,-16#80000000} = get_buf_and_term(P), + {<<110,6,0, 255,255,255,255,255,127>> , 16#7fffffffffff} = get_buf_and_term(P), + {<<110,6,1, 0,0,0,0,0,128>> ,-16#800000000000} = get_buf_and_term(P), + {<<110,8,0, 255,255,255,255,255,255,255,127>>,16#7fffffffffffffff} = get_buf_and_term(P), + {<<110,8,1, 0,0,0,0,0,0,0,128>> ,-16#8000000000000000} = get_buf_and_term(P), + + runner:recv_eot(P), + ok end. %% ######################################################################## %% -test_ei_encode_ulonglong(suite) -> []; test_ei_encode_ulonglong(Config) when is_list(Config) -> case os:type() of - vxworks -> - {skip,"Skipped on VxWorks"}; - _ -> - ?line P = runner:start(?test_ei_encode_ulonglong), - - ?line {<<97,0>> ,0} = get_buf_and_term(P), - ?line {<<97,255>> ,255} = get_buf_and_term(P), - ?line {<<98,256:32/big-unsigned-integer>>,256} = get_buf_and_term(P), - - ?line {<<98, 16#07ffffff:32/big-signed-integer>>,16#07ffffff} = get_buf_and_term(P), - ?line {<<110,4,0, 0,0,0,8>> ,16#08000000} = get_buf_and_term(P), - - ?line {<<110,4,0, 255,255,255,127>> ,16#7fffffff} = get_buf_and_term(P), - ?line {<<110,4,0, 0,0,0,128>> ,16#80000000} = get_buf_and_term(P), - ?line {<<110,4,0, 255,255,255,255>> ,16#ffffffff} = get_buf_and_term(P), - ?line {<<110,6,0, 255,255,255,255,255,255>>,16#ffffffffffff} = get_buf_and_term(P), - ?line {<<110,8,0, 255,255,255,255,255,255,255,255>>,16#ffffffffffffffff} = get_buf_and_term(P), - - ?line runner:recv_eot(P), - ok + vxworks -> + {skip,"Skipped on VxWorks"}; + _ -> + P = runner:start(?test_ei_encode_ulonglong), + + {<<97,0>> ,0} = get_buf_and_term(P), + {<<97,255>> ,255} = get_buf_and_term(P), + {<<98,256:32/big-unsigned-integer>>,256} = get_buf_and_term(P), + + {<<98, 16#07ffffff:32/big-signed-integer>>,16#07ffffff} = get_buf_and_term(P), + {<<110,4,0, 0,0,0,8>> ,16#08000000} = get_buf_and_term(P), + + {<<110,4,0, 255,255,255,127>> ,16#7fffffff} = get_buf_and_term(P), + {<<110,4,0, 0,0,0,128>> ,16#80000000} = get_buf_and_term(P), + {<<110,4,0, 255,255,255,255>> ,16#ffffffff} = get_buf_and_term(P), + {<<110,6,0, 255,255,255,255,255,255>>,16#ffffffffffff} = get_buf_and_term(P), + {<<110,8,0, 255,255,255,255,255,255,255,255>>,16#ffffffffffffffff} = get_buf_and_term(P), + + runner:recv_eot(P), + ok end. @@ -179,115 +157,112 @@ test_ei_encode_ulonglong(Config) when is_list(Config) -> %% it is unsigned. %% FIXME maybe the API should change to use "unsigned char" to be clear?! -test_ei_encode_char(suite) -> []; test_ei_encode_char(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_encode_char), + P = runner:start(?test_ei_encode_char), - ?line {<<97, 0>>,0} = get_buf_and_term(P), - ?line {<<97,127>>,16#7f} = get_buf_and_term(P), - ?line {<<97,255>>,16#ff} = get_buf_and_term(P), + {<<97, 0>>,0} = get_buf_and_term(P), + {<<97,127>>,16#7f} = get_buf_and_term(P), + {<<97,255>>,16#ff} = get_buf_and_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% ######################################################################## %% -test_ei_encode_misc(suite) -> []; test_ei_encode_misc(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_encode_misc), + P = runner:start(?test_ei_encode_misc), - ?line <<131>> = get_binaries(P), + <<131>> = get_binaries(P), - ?line {<<70,_:8/binary>>,F0} = get_buf_and_term(P), - ?line true = match_float(F0, 0.0), + {<<70,_:8/binary>>,F0} = get_buf_and_term(P), + true = match_float(F0, 0.0), - ?line {<<70,_:8/binary>>,Fn1} = get_buf_and_term(P), - ?line true = match_float(Fn1, -1.0), + {<<70,_:8/binary>>,Fn1} = get_buf_and_term(P), + true = match_float(Fn1, -1.0), - ?line {<<70,_:8/binary>>,Fp1} = get_buf_and_term(P), - ?line true = match_float(Fp1, 1.0), + {<<70,_:8/binary>>,Fp1} = get_buf_and_term(P), + true = match_float(Fp1, 1.0), - ?line {<<100,0,5,"false">>,false} = get_buf_and_term(P), - ?line {<<100,0,4,"true">> ,true} = get_buf_and_term(P), - ?line {<<100,0,4,"true">> ,true} = get_buf_and_term(P), - ?line {<<100,0,4,"true">> ,true} = get_buf_and_term(P), + {<<100,0,5,"false">>,false} = get_buf_and_term(P), + {<<100,0,4,"true">> ,true} = get_buf_and_term(P), + {<<100,0,4,"true">> ,true} = get_buf_and_term(P), + {<<100,0,4,"true">> ,true} = get_buf_and_term(P), - ?line {<<100,0,3,"foo">>,foo} = get_buf_and_term(P), - ?line {<<100,0,3,"foo">>,foo} = get_buf_and_term(P), - ?line {<<100,0,0,"">>,''} = get_buf_and_term(P), - ?line {<<100,0,0,"">>,''} = get_buf_and_term(P), - ?line {<<100,0,6,"ÅÄÖåäö">>,'ÅÄÖåäö'} = get_buf_and_term(P), - ?line {<<100,0,6,"ÅÄÖåäö">>,'ÅÄÖåäö'} = get_buf_and_term(P), + {<<100,0,3,"foo">>,foo} = get_buf_and_term(P), + {<<100,0,3,"foo">>,foo} = get_buf_and_term(P), + {<<100,0,0,"">>,''} = get_buf_and_term(P), + {<<100,0,0,"">>,''} = get_buf_and_term(P), + {<<100,0,6,"ÅÄÖåäö">>,'ÅÄÖåäö'} = get_buf_and_term(P), + {<<100,0,6,"ÅÄÖåäö">>,'ÅÄÖåäö'} = get_buf_and_term(P), - ?line {<<107,0,3,"foo">>,"foo"} = get_buf_and_term(P), - ?line {<<107,0,3,"foo">>,"foo"} = get_buf_and_term(P), - ?line {<<106>>,""} = get_buf_and_term(P), - ?line {<<106>>,""} = get_buf_and_term(P), - ?line {<<107,0,6,"ÅÄÖåäö">>,"ÅÄÖåäö"} = get_buf_and_term(P), - ?line {<<107,0,6,"ÅÄÖåäö">>,"ÅÄÖåäö"} = get_buf_and_term(P), + {<<107,0,3,"foo">>,"foo"} = get_buf_and_term(P), + {<<107,0,3,"foo">>,"foo"} = get_buf_and_term(P), + {<<106>>,""} = get_buf_and_term(P), + {<<106>>,""} = get_buf_and_term(P), + {<<107,0,6,"ÅÄÖåäö">>,"ÅÄÖåäö"} = get_buf_and_term(P), + {<<107,0,6,"ÅÄÖåäö">>,"ÅÄÖåäö"} = get_buf_and_term(P), - ?line {<<109,0,0,0,3,"foo">>,<<"foo">>} = get_buf_and_term(P), - ?line {<<109,0,0,0,0,"">>,<<>>} = get_buf_and_term(P), - ?line {<<109,0,0,0,6,"ÅÄÖåäö">>,<<"ÅÄÖåäö">>} = get_buf_and_term(P), + {<<109,0,0,0,3,"foo">>,<<"foo">>} = get_buf_and_term(P), + {<<109,0,0,0,0,"">>,<<>>} = get_buf_and_term(P), + {<<109,0,0,0,6,"ÅÄÖåäö">>,<<"ÅÄÖåäö">>} = get_buf_and_term(P), - ?line {<<104,0>>,{}} = get_buf_and_term(P), % Tuple header for {} - ?line {<<106>>,[]} = get_buf_and_term(P), % Empty list [] + {<<104,0>>,{}} = get_buf_and_term(P), % Tuple header for {} + {<<106>>,[]} = get_buf_and_term(P), % Empty list [] - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% ######################################################################## %% -test_ei_encode_fails(suite) -> []; test_ei_encode_fails(Config) when is_list(Config) -> - ?line P = runner:start(?test_ei_encode_fails), + P = runner:start(?test_ei_encode_fails), - ?line XAtom = list_to_atom(lists:duplicate(255, $x)), - ?line YAtom = list_to_atom(lists:duplicate(255, $y)), + XAtom = list_to_atom(lists:duplicate(255, $x)), + YAtom = list_to_atom(lists:duplicate(255, $y)), - ?line XAtom = get_term(P), - ?line XAtom = get_term(P), - ?line YAtom = get_term(P), - ?line YAtom = get_term(P), + XAtom = get_term(P), + XAtom = get_term(P), + YAtom = get_term(P), + YAtom = get_term(P), - ?line {{{{}}}} = get_term(P), + {{{{}}}} = get_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% ######################################################################## %% test_ei_encode_utf8_atom(Config) -> - ?line P = runner:start(?test_ei_encode_utf8_atom), - - ?line {<<119,2,195,133>>,'Ã…'} = get_buf_and_term(P), - ?line {<<100,0,1,197>>,'Ã…'} = get_buf_and_term(P), - ?line {<<100,0,1,197>>,'Ã…'} = get_buf_and_term(P), - ?line {<<119,2,195,133>>,'Ã…'} = get_buf_and_term(P), + P = runner:start(?test_ei_encode_utf8_atom), - ?line {<<119,1,$A>>,'A'} = get_buf_and_term(P), - ?line {<<100,0,1,$A>>,'A'} = get_buf_and_term(P), + {<<119,2,195,133>>,'Ã…'} = get_buf_and_term(P), + {<<100,0,1,197>>,'Ã…'} = get_buf_and_term(P), + {<<100,0,1,197>>,'Ã…'} = get_buf_and_term(P), + {<<119,2,195,133>>,'Ã…'} = get_buf_and_term(P), - ?line runner:recv_eot(P), + {<<119,1,$A>>,'A'} = get_buf_and_term(P), + {<<100,0,1,$A>>,'A'} = get_buf_and_term(P), + + runner:recv_eot(P), ok. %% ######################################################################## %% test_ei_encode_utf8_atom_len(Config) -> - ?line P = runner:start(?test_ei_encode_utf8_atom_len), - - ?line {<<119,2,195,133>>,'Ã…'} = get_buf_and_term(P), - ?line {<<100,0,2,197,196>>,'ÅÄ'} = get_buf_and_term(P), - ?line {<<100,0,1,197>>,'Ã…'} = get_buf_and_term(P), - ?line {<<119,4,195,133,195,132>>,'ÅÄ'} = get_buf_and_term(P), - - ?line {<<119,1,$A>>,'A'} = get_buf_and_term(P), - ?line {<<100,0,2,$A,$B>>,'AB'} = get_buf_and_term(P), - ?line {<<100,0,255,_:(255*8)>>,_} = get_buf_and_term(P), - - ?line runner:recv_eot(P), + P = runner:start(?test_ei_encode_utf8_atom_len), + + {<<119,2,195,133>>,'Ã…'} = get_buf_and_term(P), + {<<100,0,2,197,196>>,'ÅÄ'} = get_buf_and_term(P), + {<<100,0,1,197>>,'Ã…'} = get_buf_and_term(P), + {<<119,4,195,133,195,132>>,'ÅÄ'} = get_buf_and_term(P), + + {<<119,1,$A>>,'A'} = get_buf_and_term(P), + {<<100,0,2,$A,$B>>,'AB'} = get_buf_and_term(P), + {<<100,0,255,_:(255*8)>>,_} = get_buf_and_term(P), + + runner:recv_eot(P), ok. %% ######################################################################## %% @@ -297,20 +272,20 @@ test_ei_encode_utf8_atom_len(Config) -> get_buf_and_term(P) -> B = get_binaries(P), case B of - <<131>> -> - io:format("(got single magic, no content)\n",[]), - {B,'$$magic$$'}; - <<131,_>> -> - T = binary_to_term(B), - io:format("~w\n~w\n(got magic)\n",[B,T]), - {B,T}; - _ -> - B1 = list_to_binary([131,B]), % No magic, add - T = binary_to_term(B1), - io:format("~w\n~w\n(got no magic)\n",[B,T]), - {B,T} + <<131>> -> + io:format("(got single magic, no content)\n",[]), + {B,'$$magic$$'}; + <<131,_>> -> + T = binary_to_term(B), + io:format("~w\n~w\n(got magic)\n",[B,T]), + {B,T}; + _ -> + B1 = list_to_binary([131,B]), % No magic, add + T = binary_to_term(B1), + io:format("~w\n~w\n(got no magic)\n",[B,T]), + {B,T} end. - + get_binaries(P) -> B1 = get_binary(P), @@ -319,14 +294,14 @@ get_binaries(P) -> get_binary(P) -> case runner:get_term(P) of - {bytes,L} -> - B = list_to_binary(L), - io:format("~w\n",[L]), -% For strange reasons <<131>> show up as <>.... -% io:format("~w\n",[B]), - B; - Other -> - Other + {bytes,L} -> + B = list_to_binary(L), + io:format("~w\n",[L]), + % For strange reasons <<131>> show up as <>.... + % io:format("~w\n",[B]), + B; + Other -> + Other end. %% @@ -335,27 +310,26 @@ get_binary(P) -> get_term(P) -> case runner:get_term(P) of - {bytes,[131]} -> - io:format("(got single magic, no content)\n",[]), - '$$magic$$'; - {bytes,[131,L]} -> - B = list_to_binary(L), - T = binary_to_term(B), - io:format("~w\n~w\n(got magic)\n",[L,T]), - T; - {bytes,L} -> - B = list_to_binary([131,L]), - T = binary_to_term(B), - io:format("~w\n~w\n(got no magic)\n",[L,T]), - T; - Other -> - Other + {bytes,[131]} -> + io:format("(got single magic, no content)\n",[]), + '$$magic$$'; + {bytes,[131,L]} -> + B = list_to_binary(L), + T = binary_to_term(B), + io:format("~w\n~w\n(got magic)\n",[L,T]), + T; + {bytes,L} -> + B = list_to_binary([131,L]), + T = binary_to_term(B), + io:format("~w\n~w\n(got no magic)\n",[L,T]), + T; + Other -> + Other end. - + %% match_float(F, Match) when is_float(F), is_float(Match), F == Match -> true; match_float(F, Match) when is_float(F), F > Match*0.99, F < Match*1.01 -> true. - diff --git a/lib/erl_interface/test/ei_format_SUITE.erl b/lib/erl_interface/test/ei_format_SUITE.erl index ed6a755f9b..0054e5a14b 100644 --- a/lib/erl_interface/test/ei_format_SUITE.erl +++ b/lib/erl_interface/test/ei_format_SUITE.erl @@ -24,155 +24,131 @@ -include_lib("common_test/include/ct.hrl"). -include("ei_format_SUITE_data/ei_format_test_cases.hrl"). --export([ - format_wo_ver/1, - all/0, suite/0,groups/0, - init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - atoms/1, - tuples/1, - lists/1 - ]). +-export([format_wo_ver/1, + all/0, suite/0, + atoms/1, + tuples/1, + lists/1]). -import(runner, [get_term/1]). %% This test suite test the erl_format() function. %% It uses the port program "ei_format_test". -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}]. all() -> [format_wo_ver, atoms, tuples, lists]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - - %% Tests formatting various atoms. -atoms(suite) -> []; atoms(Config) when is_list(Config) -> - ?line P = runner:start(?atoms), - - ?line {term, ''} = get_term(P), - ?line {term, 'a'} = get_term(P), - ?line {term, 'A'} = get_term(P), - ?line {term, 'abc'} = get_term(P), - ?line {term, 'Abc'} = get_term(P), - ?line {term, 'ab@c'} = get_term(P), - ?line {term, 'The rain in Spain stays mainly in the plains'} = - get_term(P), - - ?line {term, a} = get_term(P), - ?line {term, ab} = get_term(P), - ?line {term, abc} = get_term(P), - ?line {term, ab@c} = get_term(P), - ?line {term, abcdefghijklmnopq} = get_term(P), - - ?line {term, ''} = get_term(P), - ?line {term, 'a'} = get_term(P), - ?line {term, 'A'} = get_term(P), - ?line {term, 'abc'} = get_term(P), - ?line {term, 'Abc'} = get_term(P), - ?line {term, 'ab@c'} = get_term(P), - ?line {term, 'The rain in Spain stays mainly in the plains'} = - get_term(P), - - ?line {term, a} = get_term(P), - ?line {term, ab} = get_term(P), - ?line {term, abc} = get_term(P), - ?line {term, ab@c} = get_term(P), - ?line {term, ' abcdefghijklmnopq '} = get_term(P), - - ?line runner:recv_eot(P), + P = runner:start(?atoms), + + {term, ''} = get_term(P), + {term, 'a'} = get_term(P), + {term, 'A'} = get_term(P), + {term, 'abc'} = get_term(P), + {term, 'Abc'} = get_term(P), + {term, 'ab@c'} = get_term(P), + {term, 'The rain in Spain stays mainly in the plains'} = + get_term(P), + + {term, a} = get_term(P), + {term, ab} = get_term(P), + {term, abc} = get_term(P), + {term, ab@c} = get_term(P), + {term, abcdefghijklmnopq} = get_term(P), + + {term, ''} = get_term(P), + {term, 'a'} = get_term(P), + {term, 'A'} = get_term(P), + {term, 'abc'} = get_term(P), + {term, 'Abc'} = get_term(P), + {term, 'ab@c'} = get_term(P), + {term, 'The rain in Spain stays mainly in the plains'} = + get_term(P), + + {term, a} = get_term(P), + {term, ab} = get_term(P), + {term, abc} = get_term(P), + {term, ab@c} = get_term(P), + {term, ' abcdefghijklmnopq '} = get_term(P), + + runner:recv_eot(P), ok. %% Tests formatting various tuples -tuples(suite) -> []; tuples(Config) when is_list(Config) -> - ?line P = runner:start(?tuples), - - ?line {term, {}} = get_term(P), - ?line {term, {a}} = get_term(P), - ?line {term, {a, b}} = get_term(P), - ?line {term, {a, b, c}} = get_term(P), - ?line {term, {1}} = get_term(P), - ?line {term, {[]}} = get_term(P), - ?line {term, {[], []}} = get_term(P), - ?line {term, {[], a, b, c}} = get_term(P), - ?line {term, {[], a, [], b, c}} = get_term(P), - ?line {term, {[], a, '', b, c}} = get_term(P), - - ?line runner:recv_eot(P), + P = runner:start(?tuples), + + {term, {}} = get_term(P), + {term, {a}} = get_term(P), + {term, {a, b}} = get_term(P), + {term, {a, b, c}} = get_term(P), + {term, {1}} = get_term(P), + {term, {[]}} = get_term(P), + {term, {[], []}} = get_term(P), + {term, {[], a, b, c}} = get_term(P), + {term, {[], a, [], b, c}} = get_term(P), + {term, {[], a, '', b, c}} = get_term(P), + + runner:recv_eot(P), ok. %% Tests formatting various lists -lists(suite) -> []; lists(Config) when is_list(Config) -> - ?line P = runner:start(?lists), - - ?line {term, []} = get_term(P), - ?line {term, [a]} = get_term(P), - ?line {term, [a, b]} = get_term(P), - ?line {term, [a, b, c]} = get_term(P), - ?line {term, [1]} = get_term(P), - ?line {term, [[]]} = get_term(P), - ?line {term, [[], []]} = get_term(P), - ?line {term, [[], a, b, c]} = get_term(P), - ?line {term, [[], a, [], b, c]} = get_term(P), - ?line {term, [[], a, '', b, c]} = get_term(P), - ?line {term, [[x, 2], [y, 3], [z, 4]]}= get_term(P), - ?line {term, [{a,b},{c,d}]}= get_term(P), -%% ?line {term, [{name, 'Madonna'}, {age, 21}, {data, [{addr, "E-street", 42}]}]} = -%% get_term(P), - - ?line {term, [{pi, F1}, {'cos(70)', F2}]} = get_term(P), + P = runner:start(?lists), + + {term, []} = get_term(P), + {term, [a]} = get_term(P), + {term, [a, b]} = get_term(P), + {term, [a, b, c]} = get_term(P), + {term, [1]} = get_term(P), + {term, [[]]} = get_term(P), + {term, [[], []]} = get_term(P), + {term, [[], a, b, c]} = get_term(P), + {term, [[], a, [], b, c]} = get_term(P), + {term, [[], a, '', b, c]} = get_term(P), + {term, [[x, 2], [y, 3], [z, 4]]}= get_term(P), + {term, [{a,b},{c,d}]} = get_term(P), + %% {term, [{name, 'Madonna'}, {age, 21}, {data, [{addr, "E-street", 42}]}]} = get_term(P), + + {term, [{pi, F1}, {'cos(70)', F2}]} = get_term(P), %% don't match floats directly true= abs(3.1415-F1) < 0.01, true= abs(0.34202-F2) < 0.01, - ?line {term, [[pi, F3], ['cos(70)', F4]]} = get_term(P), + {term, [[pi, F3], ['cos(70)', F4]]} = get_term(P), true= abs(3.1415-F3) < 0.01, true= abs(0.34202-F4) < 0.01, -%% ?line {term, [[pi, 3.1415], [], ["cos(70)", 0.34202]]} = get_term(P), - ?line {term, [-1]} = get_term(P), - ?line {term, "hejsan"} = get_term(P), + %% {term, [[pi, 3.1415], [], ["cos(70)", 0.34202]]} = get_term(P), + {term, [-1]} = get_term(P), + {term, "hejsan"} = get_term(P), - ?line Str1 = lists:duplicate(65535,$A), - ?line Str2 = lists:duplicate(65536,$A), - ?line {term,Str1} = get_term(P), - ?line {term,Str2} = get_term(P), + Str1 = lists:duplicate(65535,$A), + Str2 = lists:duplicate(65536,$A), + {term,Str1} = get_term(P), + {term,Str2} = get_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. -format_wo_ver(suite) -> []; format_wo_ver(Config) when is_list(Config) -> - ?line P = runner:start(?format_wo_ver), + P = runner:start(?format_wo_ver), - ?line {term, [-1, 2, $c, {a, "b"}, {c, 10}]} = get_term(P), + {term, [-1, 2, $c, {a, "b"}, {c, 10}]} = get_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. diff --git a/lib/erl_interface/test/ei_print_SUITE.erl b/lib/erl_interface/test/ei_print_SUITE.erl index 36ee90c7ee..5b5589713e 100644 --- a/lib/erl_interface/test/ei_print_SUITE.erl +++ b/lib/erl_interface/test/ei_print_SUITE.erl @@ -24,141 +24,117 @@ -include_lib("common_test/include/ct.hrl"). -include("ei_print_SUITE_data/ei_print_test_cases.hrl"). --export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - atoms/1, tuples/1, lists/1, strings/1]). +-export([all/0, suite/0, + atoms/1, tuples/1, lists/1, strings/1]). -import(runner, [get_term/1]). %% This test suite test the ei_print() function. %% It uses the port program "ei_format_test". -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}]. all() -> [atoms, tuples, lists, strings]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - - %% Tests formatting various atoms. -atoms(suite) -> []; atoms(Config) when is_list(Config) -> - ?line P = runner:start(?atoms), - - ?line {term, "''"} = get_term(P), - ?line {term, "a"} = get_term(P), - ?line {term, "'A'"} = get_term(P), - ?line {term, "abc"} = get_term(P), - ?line {term, "'Abc'"} = get_term(P), - ?line {term, "ab@c"} = get_term(P), - ?line {term, "'The rain in Spain stays mainly in the plains'"} = - get_term(P), - - ?line {term, "a"} = get_term(P), - ?line {term, "ab"} = get_term(P), - ?line {term, "abc"} = get_term(P), - ?line {term, "ab@c"} = get_term(P), - ?line {term, "abcdefghijklmnopq"} = get_term(P), - - ?line {term, "''"} = get_term(P), - ?line {term, "a"} = get_term(P), - ?line {term, "'A'"} = get_term(P), - ?line {term, "abc"} = get_term(P), - ?line {term, "'Abc'"} = get_term(P), - ?line {term, "ab@c"} = get_term(P), - ?line {term, "'The rain in Spain stays mainly in the plains'"} = - get_term(P), - - ?line {term, "a"} = get_term(P), - ?line {term, "ab"} = get_term(P), - ?line {term, "abc"} = get_term(P), - ?line {term, "ab@c"} = get_term(P), - ?line {term, "' abcdefghijklmnopq '"} = get_term(P), - - ?line runner:recv_eot(P), + P = runner:start(?atoms), + + {term, "''"} = get_term(P), + {term, "a"} = get_term(P), + {term, "'A'"} = get_term(P), + {term, "abc"} = get_term(P), + {term, "'Abc'"} = get_term(P), + {term, "ab@c"} = get_term(P), + {term, "'The rain in Spain stays mainly in the plains'"} = get_term(P), + + {term, "a"} = get_term(P), + {term, "ab"} = get_term(P), + {term, "abc"} = get_term(P), + {term, "ab@c"} = get_term(P), + {term, "abcdefghijklmnopq"} = get_term(P), + + {term, "''"} = get_term(P), + {term, "a"} = get_term(P), + {term, "'A'"} = get_term(P), + {term, "abc"} = get_term(P), + {term, "'Abc'"} = get_term(P), + {term, "ab@c"} = get_term(P), + {term, "'The rain in Spain stays mainly in the plains'"} = get_term(P), + + {term, "a"} = get_term(P), + {term, "ab"} = get_term(P), + {term, "abc"} = get_term(P), + {term, "ab@c"} = get_term(P), + {term, "' abcdefghijklmnopq '"} = get_term(P), + + runner:recv_eot(P), ok. %% Tests formatting various tuples -tuples(suite) -> []; tuples(Config) when is_list(Config) -> - ?line P = runner:start(?tuples), - - ?line {term, "{}"} = get_term(P), - ?line {term, "{a}"} = get_term(P), - ?line {term, "{a, b}"} = get_term(P), - ?line {term, "{a, b, c}"} = get_term(P), - ?line {term, "{1}"} = get_term(P), - ?line {term, "{[]}"} = get_term(P), - ?line {term, "{[], []}"} = get_term(P), - ?line {term, "{[], a, b, c}"} = get_term(P), - ?line {term, "{[], a, [], b, c}"} = get_term(P), - ?line {term, "{[], a, '', b, c}"} = get_term(P), - - ?line runner:recv_eot(P), + P = runner:start(?tuples), + + {term, "{}"} = get_term(P), + {term, "{a}"} = get_term(P), + {term, "{a, b}"} = get_term(P), + {term, "{a, b, c}"} = get_term(P), + {term, "{1}"} = get_term(P), + {term, "{[]}"} = get_term(P), + {term, "{[], []}"} = get_term(P), + {term, "{[], a, b, c}"} = get_term(P), + {term, "{[], a, [], b, c}"} = get_term(P), + {term, "{[], a, '', b, c}"} = get_term(P), + + runner:recv_eot(P), ok. %% Tests formatting various lists -lists(suite) -> []; lists(Config) when is_list(Config) -> - ?line P = runner:start(?lists), - - ?line {term, "[]"} = get_term(P), - ?line {term, "[a]"} = get_term(P), - ?line {term, "[a, b]"} = get_term(P), - ?line {term, "[a, b, c]"} = get_term(P), - ?line {term, "[1]"} = get_term(P), - ?line {term, "[[]]"} = get_term(P), - ?line {term, "[[], []]"} = get_term(P), - ?line {term, "[[], a, b, c]"} = get_term(P), - ?line {term, "[[], a, [], b, c]"} = get_term(P), - ?line {term, "[[], a, '', b, c]"} = get_term(P), - ?line {term, "[[x, 2], [y, 3], [z, 4]]"}= get_term(P), - -%% ?line {term, "[{name, 'Madonna'}, {age, 21}, {data, [{addr, "E-street", 42}]}]"} = -%% get_term(P), + P = runner:start(?lists), + + {term, "[]"} = get_term(P), + {term, "[a]"} = get_term(P), + {term, "[a, b]"} = get_term(P), + {term, "[a, b, c]"} = get_term(P), + {term, "[1]"} = get_term(P), + {term, "[[]]"} = get_term(P), + {term, "[[], []]"} = get_term(P), + {term, "[[], a, b, c]"} = get_term(P), + {term, "[[], a, [], b, c]"} = get_term(P), + {term, "[[], a, '', b, c]"} = get_term(P), + {term, "[[x, 2], [y, 3], [z, 4]]"}= get_term(P), + + %% {term, "[{name, 'Madonna'}, {age, 21}, {data, [{addr, "E-street", 42}]}]"} = get_term(P), %% maybe regexp instead? - ?line {term, "[{pi, 3.141500}, {'cos(70)', 0.342020}]"} = get_term(P), - ?line {term, "[[pi, 3.141500], ['cos(70)', 0.342020]]"} = get_term(P), + {term, "[{pi, 3.141500}, {'cos(70)', 0.342020}]"} = get_term(P), + {term, "[[pi, 3.141500], ['cos(70)', 0.342020]]"} = get_term(P), - ?line {term, "[-1]"} = get_term(P), + {term, "[-1]"} = get_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. -strings(suite) -> []; strings(Config) when is_list(Config) -> - ?line P = runner:start(?strings), - - ?line {term, "\"\\n\""} = get_term(P), - ?line {term, "\"\\r\\n\""} = get_term(P), - ?line {term, "\"a\""} = get_term(P), - ?line {term, "\"A\""} = get_term(P), - ?line {term, "\"0\""} = get_term(P), - ?line {term, "\"9\""} = get_term(P), - ?line {term, "\"The rain in Spain stays mainly in the plains\""} = get_term(P), - ?line {term, "\" abcdefghijklmnopq \""} = get_term(P), - - ?line runner:recv_eot(P), + P = runner:start(?strings), + + {term, "\"\\n\""} = get_term(P), + {term, "\"\\r\\n\""} = get_term(P), + {term, "\"a\""} = get_term(P), + {term, "\"A\""} = get_term(P), + {term, "\"0\""} = get_term(P), + {term, "\"9\""} = get_term(P), + {term, "\"The rain in Spain stays mainly in the plains\""} = get_term(P), + {term, "\" abcdefghijklmnopq \""} = get_term(P), + + runner:recv_eot(P), ok. - diff --git a/lib/erl_interface/test/ei_tmo_SUITE.erl b/lib/erl_interface/test/ei_tmo_SUITE.erl index f506b3dbb0..4cd4202116 100644 --- a/lib/erl_interface/test/ei_tmo_SUITE.erl +++ b/lib/erl_interface/test/ei_tmo_SUITE.erl @@ -27,176 +27,148 @@ -define(dummy_host,test01). --export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - init_per_testcase/2, end_per_testcase/2, - framework_check/1, ei_accept_tmo/1, ei_connect_tmo/1, ei_send_tmo/1, - ei_recv_tmo/1]). +-export([all/0, suite/0, + init_per_testcase/2, end_per_testcase/2, + framework_check/1, ei_accept_tmo/1, ei_connect_tmo/1, ei_send_tmo/1, + ei_recv_tmo/1]). -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}, + {timetrap, {minutes, 1}}]. all() -> [framework_check, ei_accept_tmo, ei_connect_tmo, ei_send_tmo, ei_recv_tmo]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - - init_per_testcase(_Case, Config) -> - Dog = ?t:timetrap(?t:minutes(1)), % test if platform is vxworks_simso - ?line {_,Host} = split(node()), + {_,Host} = split(node()), Bool = case atom_to_list(Host) of - [$v,$x,$s,$i,$m | _] -> true; - _ -> false - end, - [{vxsim,Bool},{watchdog, Dog}|Config]. - -end_per_testcase(_Case, Config) -> - Dog = ?config(watchdog, Config), - test_server:timetrap_cancel(Dog), + [$v,$x,$s,$i,$m | _] -> true; + _ -> false + end, + [{vxsim,Bool}|Config]. + +end_per_testcase(_Case, _Config) -> ok. -framework_check(doc) -> - ["Check the framework."]; -framework_check(suite) -> - []; +%% Check the framework. framework_check(Config) when is_list(Config) -> %%dbg:tracer(), %%dbg:p(self()), - ?line P = runner:start(?framework_check), - ?line runner:send_term(P,{hello,world}), - ?line {term, {hello,world}} = runner:get_term(P), - ?line runner:recv_eot(P), + P = runner:start(?framework_check), + runner:send_term(P,{hello,world}), + {term, {hello,world}} = runner:get_term(P), + runner:recv_eot(P), ok. -ei_recv_tmo(doc) -> - ["Check recv with timeouts."]; -ei_recv_tmo(suite) -> - []; +%% Check recv with timeouts. ei_recv_tmo(Config) when is_list(Config) -> - ?line do_one_recv(Config,c_node_recv_tmo_1), - ?line do_one_recv_failure(Config,c_node_recv_tmo_2), + do_one_recv(Config,c_node_recv_tmo_1), + do_one_recv_failure(Config,c_node_recv_tmo_2), ok. do_one_recv(Config,CNode) -> - ?line {_,Host} = split(node()), - ?line P1 = runner:start(?recv_tmo), - ?line runner:send_term(P1,{CNode, - erlang:get_cookie(), - node()}), - ?line {term, X} = runner:get_term(P1, 10000), - ?line true = is_integer(X), - ?line CNode1 = join(CNode,Host), - ?line Term1 = {hej,[hopp,{i,[lingon,"skogen"]}]}, - ?line {test,CNode1} ! Term1, - ?line {term, Term1} = runner:get_term(P1, 10000), - ?line runner:recv_eot(P1). - + {_,Host} = split(node()), + P1 = runner:start(?recv_tmo), + runner:send_term(P1,{CNode, + erlang:get_cookie(), + node()}), + {term, X} = runner:get_term(P1, 10000), + true = is_integer(X), + CNode1 = join(CNode,Host), + Term1 = {hej,[hopp,{i,[lingon,"skogen"]}]}, + {test,CNode1} ! Term1, + {term, Term1} = runner:get_term(P1, 10000), + runner:recv_eot(P1). + do_one_recv_failure(Config,CNode) -> - ?line P1 = runner:start(?recv_tmo), - ?line runner:send_term(P1,{CNode, - erlang:get_cookie(), - node()}), - ?line {term, X} = runner:get_term(P1, 10000), - ?line true = is_integer(X), - ?line {term, {Ret,ETimedout,ETimedout}} = runner:get_term(P1, 10000), - ?line true = (Ret < 0), - ?line runner:recv_eot(P1). - - -ei_send_tmo(doc) -> - ["Check send with timeouts."]; -ei_send_tmo(suite) -> - []; + P1 = runner:start(?recv_tmo), + runner:send_term(P1,{CNode, + erlang:get_cookie(), + node()}), + {term, X} = runner:get_term(P1, 10000), + true = is_integer(X), + {term, {Ret,ETimedout,ETimedout}} = runner:get_term(P1, 10000), + true = (Ret < 0), + runner:recv_eot(P1). + + +%% Check send with timeouts. ei_send_tmo(Config) when is_list(Config) -> %dbg:tracer(), %dbg:p(self()), - VxSim = ?config(vxsim, Config), - ?line register(ei_send_tmo_1,self()), - ?line do_one_send(Config,self(),c_node_send_tmo_1), - ?line do_one_send(Config,ei_send_tmo_1,c_node_send_tmo_2), - ?line do_one_send_failure(Config,self(),cccc1,c_nod_send_tmo_3,VxSim), - ?line do_one_send_failure(Config,ei_send_tmo_1,cccc2,c_nod_send_tmo_4,VxSim), + VxSim = proplists:get_value(vxsim, Config), + register(ei_send_tmo_1,self()), + do_one_send(Config,self(),c_node_send_tmo_1), + do_one_send(Config,ei_send_tmo_1,c_node_send_tmo_2), + do_one_send_failure(Config,self(),cccc1,c_nod_send_tmo_3,VxSim), + do_one_send_failure(Config,ei_send_tmo_1,cccc2,c_nod_send_tmo_4,VxSim), ok. - + do_one_send(Config,From,CNode) -> - ?line {_,Host} = split(node()), - ?line P1 = runner:start(?send_tmo), - ?line runner:send_term(P1,{CNode, - erlang:get_cookie(), - node()}), - ?line {term, X} = runner:get_term(P1, 10000), - ?line true = is_integer(X), - ?line CNode1 = join(CNode,Host), - ?line Term1 = {hej,[hopp,{i,[lingon,"skogen"]}]}, - ?line {test,CNode1} ! {From,1,Term1}, - ?line ok = receive - Term1 -> - ok - after 2000 -> - error - end, - ?line {term, 0} = runner:get_term(P1, 10000), - ?line runner:recv_eot(P1). + {_,Host} = split(node()), + P1 = runner:start(?send_tmo), + runner:send_term(P1,{CNode, + erlang:get_cookie(), + node()}), + {term, X} = runner:get_term(P1, 10000), + true = is_integer(X), + CNode1 = join(CNode,Host), + Term1 = {hej,[hopp,{i,[lingon,"skogen"]}]}, + {test,CNode1} ! {From,1,Term1}, + ok = receive + Term1 -> + ok + after 2000 -> + error + end, + {term, 0} = runner:get_term(P1, 10000), + runner:recv_eot(P1). do_one_send_failure(Config,From,FakeName,CName,VxSim) -> - ?line {_,Host} = split(node()), - ?line OurName = join(FakeName,Host), - ?line Node = join(CName,Host), - ?line LSocket = case gen_tcp:listen(0, [{active, false}, {packet,2}]) of - {ok, Socket} -> - ?line Socket; - Else -> - ?line exit(Else) - end, - ?line EpmdSocket = register(OurName, LSocket, 1, 5), - ?line P3 = runner:start(?send_tmo), - ?line Cookie = kaksmula_som_ingen_bryr_sig_om, - ?line runner:send_term(P3,{CName, - Cookie, - OurName}), - ?line SocketB = case gen_tcp:accept(LSocket) of - {ok, Socket1} -> - ?line Socket1; - Else2 -> - ?line exit(Else2) - end, - ?line {hidden,Node,5} = recv_name(SocketB), % See 1) - ?line send_status(SocketB, ok), - ?line MyChallengeB = gen_challenge(), - ?line send_challenge(SocketB, OurName, MyChallengeB, 5), - ?line HisChallengeB = recv_challenge_reply( - SocketB, - MyChallengeB, - Cookie), - ?line DigestB = gen_digest(HisChallengeB,Cookie), - ?line send_challenge_ack(SocketB, DigestB), - ?line inet:setopts(SocketB, [{active, false}, - {packet, 4}]), - ?line {term, X} = runner:get_term(P3, 10000), - ?line true = is_integer(X), - ?line Message = [112,term_to_binary({6,self(),'',test}), - term_to_binary({From,10000, - {app,["lapp",{sa,["att",du,{slapp, - sitta}]}]}})], - ?line gen_tcp:send(SocketB,Message), + {_,Host} = split(node()), + OurName = join(FakeName,Host), + Node = join(CName,Host), + LSocket = case gen_tcp:listen(0, [{active, false}, {packet,2}]) of + {ok, Socket} -> + Socket; + Else -> + exit(Else) + end, + EpmdSocket = register(OurName, LSocket, 1, 5), + P3 = runner:start(?send_tmo), + Cookie = kaksmula_som_ingen_bryr_sig_om, + runner:send_term(P3,{CName, + Cookie, + OurName}), + SocketB = case gen_tcp:accept(LSocket) of + {ok, Socket1} -> + Socket1; + Else2 -> + exit(Else2) + end, + {hidden,Node,5} = recv_name(SocketB), % See 1) + send_status(SocketB, ok), + MyChallengeB = gen_challenge(), + send_challenge(SocketB, OurName, MyChallengeB, 5), + HisChallengeB = recv_challenge_reply(SocketB, + MyChallengeB, + Cookie), + DigestB = gen_digest(HisChallengeB,Cookie), + send_challenge_ack(SocketB, DigestB), + inet:setopts(SocketB, [{active, false}, + {packet, 4}]), + {term, X} = runner:get_term(P3, 10000), + true = is_integer(X), + Message = [112,term_to_binary({6,self(),'',test}), + term_to_binary({From,10000, + {app,["lapp",{sa,["att",du,{slapp, + sitta}]}]}})], + gen_tcp:send(SocketB,Message), %% At this point the test program starts sending messages (max 10000). Since %% we're not receiving, eventually the send buffer fills up. Then no more @@ -204,152 +176,145 @@ do_one_send_failure(Config,From,FakeName,CName,VxSim) -> %% before this happens is returned in Iters. The timeout value for get_term/2 %% must be large enough so there's time for the select() to time out and %% the test program to return the error tuple (below). - Res0 = - if VxSim == false -> - ?line {term,{Res,ETO,Iters,ETO}} = runner:get_term(P3, 20000), - Res; - true -> % relax the test for vxsim - ?line case runner:get_term(P3, 20000) of - {term,{Res,ETO,Iters,ETO}} -> - Res; - {term,{Res,_,Iters,ETO}} -> % EIO? - Res - end - end, - ?line runner:recv_eot(P3), - ?line true = ((Res0 < 0) and (Iters > 0)), - ?line gen_tcp:close(SocketB), - ?line gen_tcp:close(EpmdSocket), + + Res0 = if VxSim == false -> + {term,{Res,ETO,Iters,ETO}} = runner:get_term(P3, 20000), + Res; + true -> % relax the test for vxsim + case runner:get_term(P3, 20000) of + {term,{Res,ETO,Iters,ETO}} -> + Res; + {term,{Res,_,Iters,_ETO}} -> % EIO? + Res + end + end, + runner:recv_eot(P3), + true = ((Res0 < 0) and (Iters > 0)), + gen_tcp:close(SocketB), + gen_tcp:close(EpmdSocket), ok. - -ei_connect_tmo(doc) -> - ["Check accept with timeouts."]; -ei_connect_tmo(suite) -> - []; + +%% Check accept with timeouts. ei_connect_tmo(Config) when is_list(Config) -> %dbg:tracer(), %dbg:p(self()), - VxSim = ?config(vxsim, Config), + VxSim = proplists:get_value(vxsim, Config), DummyNode = make_and_check_dummy(), - ?line P = runner:start(?connect_tmo), - ?line runner:send_term(P,{c_nod_connect_tmo_1, - kaksmula_som_ingen_bryr_sig_om, - DummyNode}), + P = runner:start(?connect_tmo), + runner:send_term(P,{c_nod_connect_tmo_1, + kaksmula_som_ingen_bryr_sig_om, + DummyNode}), ETimedout = - if VxSim == false -> - ?line {term,{-3,ETO,ETO}} = runner:get_term(P, 10000), - ?line ETO; - true -> % relax the test for vxsim - ?line case runner:get_term(P, 10000) of - {term,{-3,ETO,ETO}} -> - ?line ETO; - {term,{-1,_,ETO}} -> % EHOSTUNREACH = ok - ?line ETO - end - end, - ?line runner:recv_eot(P), - ?line P2 = runner:start(?connect_tmo), - ?line runner:send_term(P2,{c_nod_connect_tmo_2, - erlang:get_cookie(), - node()}), - ?line {term, X} = runner:get_term(P2, 10000), - ?line runner:recv_eot(P2), - ?line true = is_integer(X), + if VxSim == false -> + {term,{-3,ETO,ETO}} = runner:get_term(P, 10000), + ETO; + true -> % relax the test for vxsim + case runner:get_term(P, 10000) of + {term,{-3,ETO,ETO}} -> + ETO; + {term,{-1,_,ETO}} -> % EHOSTUNREACH = ok + ETO + end + end, + runner:recv_eot(P), + P2 = runner:start(?connect_tmo), + runner:send_term(P2,{c_nod_connect_tmo_2, + erlang:get_cookie(), + node()}), + {term, X} = runner:get_term(P2, 10000), + runner:recv_eot(P2), + true = is_integer(X), %% Aborted handshake test... - ?line {_,Host} = split(node()), - ?line OurName = join(cccc,Host), - ?line Node = join(c_nod_connect_tmo_3,Host), - ?line LSocket = case gen_tcp:listen(0, [{active, false}, {packet,2}]) of - {ok, Socket} -> - ?line Socket; - Else -> - ?line exit(Else) - end, - ?line EpmdSocket = register(OurName, LSocket, 1, 5), - ?line P3 = runner:start(?connect_tmo), - ?line Cookie = kaksmula_som_ingen_bryr_sig_om, - ?line runner:send_term(P3,{c_nod_connect_tmo_3, - Cookie, - OurName}), - ?line SocketB = case gen_tcp:accept(LSocket) of - {ok, Socket1} -> - ?line Socket1; - Else2 -> - ?line exit(Else2) - end, - ?line {hidden,Node,5} = recv_name(SocketB), % See 1) - ?line send_status(SocketB, ok), - ?line MyChallengeB = gen_challenge(), - ?line send_challenge(SocketB, OurName, MyChallengeB, 5), - ?line HisChallengeB = recv_challenge_reply( - SocketB, - MyChallengeB, - Cookie), - ?line {term,{-1,ETimedout,ETimedout}} = runner:get_term(P3, 10000), - ?line runner:recv_eot(P3), - ?line gen_tcp:close(SocketB), - ?line gen_tcp:close(EpmdSocket), + {_,Host} = split(node()), + OurName = join(cccc,Host), + Node = join(c_nod_connect_tmo_3,Host), + LSocket = case gen_tcp:listen(0, [{active, false}, {packet,2}]) of + {ok, Socket} -> + Socket; + Else -> + exit(Else) + end, + EpmdSocket = register(OurName, LSocket, 1, 5), + P3 = runner:start(?connect_tmo), + Cookie = kaksmula_som_ingen_bryr_sig_om, + runner:send_term(P3,{c_nod_connect_tmo_3, + Cookie, + OurName}), + SocketB = case gen_tcp:accept(LSocket) of + {ok, Socket1} -> + Socket1; + Else2 -> + exit(Else2) + end, + {hidden,Node,5} = recv_name(SocketB), % See 1) + send_status(SocketB, ok), + MyChallengeB = gen_challenge(), + send_challenge(SocketB, OurName, MyChallengeB, 5), + _HisChallengeB = recv_challenge_reply(SocketB, + MyChallengeB, + Cookie), + {term,{-1,ETimedout,ETimedout}} = runner:get_term(P3, 10000), + runner:recv_eot(P3), + gen_tcp:close(SocketB), + gen_tcp:close(EpmdSocket), ok. - -ei_accept_tmo(doc) -> - ["Check accept with timeouts."]; -ei_accept_tmo(suite) -> - []; + +%% Check accept with timeouts. ei_accept_tmo(Config) when is_list(Config) -> %%dbg:tracer(), %%dbg:p(self()), - ?line P = runner:start(?accept_tmo), - ?line runner:send_term(P,{c_nod_som_ingen_kontaktar_1, - kaksmula_som_ingen_bryr_sig_om}), - ?line {term,{-1,ETimedout,ETimedout}} = runner:get_term(P, 10000), - ?line runner:recv_eot(P), - ?line P2 = runner:start(?accept_tmo), - ?line runner:send_term(P2,{c_nod_som_vi_kontaktar_1, - erlang:get_cookie()}), - ?line receive after 1000 -> ok end, - ?line CNode1 = make_node(c_nod_som_vi_kontaktar_1), - ?line {ignored,CNode1} ! tjenare, - ?line {term, X} = runner:get_term(P2, 10000), - ?line runner:recv_eot(P2), - ?line true = is_integer(X), - ?line P3 = runner:start(?accept_tmo), - ?line runner:send_term(P3,{c_nod_som_vi_kontaktar_2, - erlang:get_cookie()}), - ?line receive after 1000 -> ok end, - ?line CNode2 = make_node(c_nod_som_vi_kontaktar_2), - ?line {NA,NB} = split(CNode2), - ?line {_,Host} = split(node()), - ?line OurName = join(ccc,Host), - ?line {port,PortNo,_} = erl_epmd:port_please(NA,NB), - ?line {ok, SocketA} = gen_tcp:connect(atom_to_list(NB),PortNo, - [{active,false}, - {packet,2}]), - ?line send_name(SocketA,OurName,5), - ?line ok = recv_status(SocketA), - ?line {hidden,Node,5,HisChallengeA} = recv_challenge(SocketA), % See 1) - ?line OurChallengeA = gen_challenge(), - ?line OurDigestA = gen_digest(HisChallengeA, erlang:get_cookie()), + P = runner:start(?accept_tmo), + runner:send_term(P,{c_nod_som_ingen_kontaktar_1, + kaksmula_som_ingen_bryr_sig_om}), + {term,{-1,ETimedout,ETimedout}} = runner:get_term(P, 10000), + runner:recv_eot(P), + P2 = runner:start(?accept_tmo), + runner:send_term(P2,{c_nod_som_vi_kontaktar_1, + erlang:get_cookie()}), + receive after 1000 -> ok end, + CNode1 = make_node(c_nod_som_vi_kontaktar_1), + {ignored,CNode1} ! tjenare, + {term, X} = runner:get_term(P2, 10000), + runner:recv_eot(P2), + true = is_integer(X), + P3 = runner:start(?accept_tmo), + runner:send_term(P3,{c_nod_som_vi_kontaktar_2, + erlang:get_cookie()}), + receive after 1000 -> ok end, + CNode2 = make_node(c_nod_som_vi_kontaktar_2), + {NA,NB} = split(CNode2), + {_,Host} = split(node()), + OurName = join(ccc,Host), + {port,PortNo,_} = erl_epmd:port_please(NA,NB), + {ok, SocketA} = gen_tcp:connect(atom_to_list(NB),PortNo, + [{active,false}, + {packet,2}]), + send_name(SocketA,OurName,5), + ok = recv_status(SocketA), + {hidden,_Node,5,HisChallengeA} = recv_challenge(SocketA), % See 1) + _OurChallengeA = gen_challenge(), + _OurDigestA = gen_digest(HisChallengeA, erlang:get_cookie()), %% Dont do the last two steps of the connection setup... %% send_challenge_reply(SocketA, OurChallengeA, OurDigestA), %% ok = recv_challenge_ack(SocketA, OurChallengeA, erlang:get_cookie()), - ?line {term, {-1,ETimedout,ETimedout}} = runner:get_term(P3, 10000), - ?line runner:recv_eot(P3), - ?line gen_tcp:close(SocketA), + {term, {-1,ETimedout,ETimedout}} = runner:get_term(P3, 10000), + runner:recv_eot(P3), + gen_tcp:close(SocketA), ok. make_node(X) -> list_to_atom(atom_to_list(X) ++ "@" ++ - hd(tl(string:tokens(atom_to_list(node()),"@")))). + hd(tl(string:tokens(atom_to_list(node()),"@")))). make_and_check_dummy() -> % First check that the host has an ip and is *not* reachable - ?line case gen_tcp:connect(?dummy_host,23,[{active,false}],5000) of - {error,timeout} -> ok; - {error,ehostunreach} -> ok - end, + case gen_tcp:connect(?dummy_host,23,[{active,false}],5000) of + {error,timeout} -> ok; + {error,ehostunreach} -> ok + end, list_to_atom("dummy@"++atom_to_list(?dummy_host)). @@ -359,12 +324,12 @@ make_and_check_dummy() -> %% -define(to_port(Socket, Data), - case inet_tcp:send(Socket, Data) of - {error, closed} -> - self() ! {tcp_closed, Socket}, - {error, closed}; - R -> - R + case inet_tcp:send(Socket, Data) of + {error, closed} -> + self() ! {tcp_closed, Socket}, + {error, closed}; + R -> + R end). -define(DFLAG_PUBLISHED,1). @@ -382,8 +347,8 @@ make_and_check_dummy() -> -define(int16(X), [((X) bsr 8) band 16#ff, (X) band 16#ff]). -define(int32(X), - [((X) bsr 24) band 16#ff, ((X) bsr 16) band 16#ff, - ((X) bsr 8) band 16#ff, (X) band 16#ff]). + [((X) bsr 24) band 16#ff, ((X) bsr 16) band 16#ff, + ((X) bsr 8) band 16#ff, (X) band 16#ff]). -define(i16(X1,X0), (?u16(X1,X0) - @@ -406,9 +371,9 @@ make_and_check_dummy() -> %% This is no proper random number, but that is not really important in %% this test gen_challenge() -> - {_,_,N} = erlang:now(), + {_,_,N} = os:timestamp(), N. - + %% Generate a message digest from Challenge number and Cookie gen_digest(Challenge, Cookie) when is_integer(Challenge), is_atom(Cookie) -> C0 = erlang:md5_init(), @@ -423,95 +388,93 @@ gen_digest(Challenge, Cookie) when is_integer(Challenge), is_atom(Cookie) -> send_status(Socket, Stat) -> case gen_tcp:send(Socket, [$s | atom_to_list(Stat)]) of - {error, _} -> - ?shutdown(could_not_send_status); - _ -> - true + {error, _} -> ?shutdown(could_not_send_status); + _ -> true end. recv_status(Socket) -> case gen_tcp:recv(Socket, 0) of - {ok, [$s|StrStat]} -> - list_to_atom(StrStat); - Bad -> - exit(Bad) + {ok, [$s|StrStat]} -> + list_to_atom(StrStat); + Bad -> + exit(Bad) end. send_challenge(Socket, Node, Challenge, Version) -> send_challenge(Socket, Node, Challenge, Version, ?COMPULSORY_DFLAGS). send_challenge(Socket, Node, Challenge, Version, Flags) -> - {ok, {{Ip1,Ip2,Ip3,Ip4}, _}} = inet:sockname(Socket), + {ok, {{_Ip1,_Ip2,_Ip3,_Ip4}, _}} = inet:sockname(Socket), ?to_port(Socket, [$n,?int16(Version),?int32(Flags), - ?int32(Challenge), atom_to_list(Node)]). + ?int32(Challenge), atom_to_list(Node)]). recv_challenge(Socket) -> case gen_tcp:recv(Socket, 0) of - {ok,[$n,V1,V0,Fl1,Fl2,Fl3,Fl4,CA3,CA2,CA1,CA0 | Ns]} -> - Flags = ?u32(Fl1,Fl2,Fl3,Fl4), - Type = case Flags band ?DFLAG_PUBLISHED of - 0 -> - hidden; - _ -> - normal - end, - Node =list_to_atom(Ns), - Version = ?u16(V1,V0), - Challenge = ?u32(CA3,CA2,CA1,CA0), - {Type,Node,Version,Challenge}; - _ -> - ?shutdown(no_node) + {ok,[$n,V1,V0,Fl1,Fl2,Fl3,Fl4,CA3,CA2,CA1,CA0 | Ns]} -> + Flags = ?u32(Fl1,Fl2,Fl3,Fl4), + Type = case Flags band ?DFLAG_PUBLISHED of + 0 -> + hidden; + _ -> + normal + end, + Node =list_to_atom(Ns), + Version = ?u16(V1,V0), + Challenge = ?u32(CA3,CA2,CA1,CA0), + {Type,Node,Version,Challenge}; + _ -> + ?shutdown(no_node) end. -send_challenge_reply(Socket, Challenge, Digest) -> - ?to_port(Socket, [$r,?int32(Challenge),Digest]). +%send_challenge_reply(Socket, Challenge, Digest) -> +% ?to_port(Socket, [$r,?int32(Challenge),Digest]). recv_challenge_reply(Socket, ChallengeA, Cookie) -> case gen_tcp:recv(Socket, 0) of - {ok,[$r,CB3,CB2,CB1,CB0 | SumB]} when length(SumB) == 16 -> - SumA = gen_digest(ChallengeA, Cookie), - ChallengeB = ?u32(CB3,CB2,CB1,CB0), - if SumB == SumA -> - ChallengeB; - true -> - ?shutdown(bad_challenge_reply) - end; - _ -> - ?shutdown(no_node) + {ok,[$r,CB3,CB2,CB1,CB0 | SumB]} when length(SumB) == 16 -> + SumA = gen_digest(ChallengeA, Cookie), + ChallengeB = ?u32(CB3,CB2,CB1,CB0), + if SumB == SumA -> + ChallengeB; + true -> + ?shutdown(bad_challenge_reply) + end; + _ -> + ?shutdown(no_node) end. send_challenge_ack(Socket, Digest) -> ?to_port(Socket, [$a,Digest]). -recv_challenge_ack(Socket, ChallengeB, CookieA) -> - case gen_tcp:recv(Socket, 0) of - {ok,[$a | SumB]} when length(SumB) == 16 -> - SumA = gen_digest(ChallengeB, CookieA), - if SumB == SumA -> - ok; - true -> - ?shutdown(bad_challenge_ack) - end; - _ -> - ?shutdown(bad_challenge_ack) - end. +%recv_challenge_ack(Socket, ChallengeB, CookieA) -> +% case gen_tcp:recv(Socket, 0) of +% {ok,[$a | SumB]} when length(SumB) == 16 -> +% SumA = gen_digest(ChallengeB, CookieA), +% if SumB == SumA -> +% ok; +% true -> +% ?shutdown(bad_challenge_ack) +% end; +% _ -> +% ?shutdown(bad_challenge_ack) +% end. send_name(Socket, MyNode0, Version) -> send_name(Socket, MyNode0, Version, ?COMPULSORY_DFLAGS). send_name(Socket, MyNode0, Version, Flags) -> MyNode = atom_to_list(MyNode0), ?to_port(Socket, [$n,?int16(Version),?int32(Flags)] ++ - MyNode). + MyNode). %% %% recv_name is common for both old and new handshake. %% recv_name(Socket) -> case gen_tcp:recv(Socket, 0) of - {ok,Data} -> - get_name(Data); - Res -> - ?shutdown({no_node,Res}) + {ok,Data} -> + get_name(Data); + Res -> + ?shutdown({no_node,Res}) end. get_name([$m,VersionA,VersionB,_Ip1,_Ip2,_Ip3,_Ip4|OtherNode]) -> @@ -520,11 +483,9 @@ get_name([$h,VersionA,VersionB,_Ip1,_Ip2,_Ip3,_Ip4|OtherNode]) -> {hidden, list_to_atom(OtherNode), ?u16(VersionA,VersionB)}; get_name([$n,VersionA, VersionB, Flag1, Flag2, Flag3, Flag4 | OtherNode]) -> Type = case ?u32(Flag1, Flag2, Flag3, Flag4) band ?DFLAG_PUBLISHED of - 0 -> - hidden; - _ -> - normal - end, + 0 -> hidden; + _ -> normal + end, {Type, list_to_atom(OtherNode), ?u16(VersionA,VersionB)}; get_name(Data) -> @@ -533,74 +494,73 @@ get_name(Data) -> %% %% tell_name is for old handshake %% -tell_name(Socket, MyNode0, Version) -> - MyNode = atom_to_list(MyNode0), - {ok, {{Ip1,Ip2,Ip3,Ip4}, _}} = inet:sockname(Socket), - ?to_port(Socket, [$h,?int16(Version),Ip1,Ip2,Ip3,Ip4] ++ - MyNode). +%tell_name(Socket, MyNode0, Version) -> +% MyNode = atom_to_list(MyNode0), +% {ok, {{Ip1,Ip2,Ip3,Ip4}, _}} = inet:sockname(Socket), +% ?to_port(Socket, [$h,?int16(Version),Ip1,Ip2,Ip3,Ip4] ++ MyNode). %% %% The communication with EPMD follows %% do_register_node(NodeName, TcpPort, VLow, VHigh) -> case gen_tcp:connect({127,0,0,1}, get_epmd_port(), []) of - {ok, Socket} -> - {N0,_} = split(NodeName), - Name = atom_to_list(N0), - Extra = "", - Elen = length(Extra), - Len = 1+2+1+1+2+2+2+length(Name)+2+Elen, - gen_tcp:send(Socket, [?int16(Len), $x, - ?int16(TcpPort), - $M, - 0, - ?int16(VHigh), - ?int16(VLow), - ?int16(length(Name)), - Name, - ?int16(Elen), - Extra]), - case wait_for_reg_reply(Socket, []) of - {error, epmd_close} -> - exit(epmd_broken); - Other -> - Other - end; - Error -> - Error + {ok, Socket} -> + {N0,_} = split(NodeName), + Name = atom_to_list(N0), + Extra = "", + Elen = length(Extra), + Len = 1+2+1+1+2+2+2+length(Name)+2+Elen, + gen_tcp:send(Socket, [?int16(Len), $x, + ?int16(TcpPort), + $M, + 0, + ?int16(VHigh), + ?int16(VLow), + ?int16(length(Name)), + Name, + ?int16(Elen), + Extra]), + case wait_for_reg_reply(Socket, []) of + {error, epmd_close} -> + exit(epmd_broken); + Other -> + Other + end; + Error -> + Error end. wait_for_reg_reply(Socket, SoFar) -> receive - {tcp, Socket, Data0} -> - case SoFar ++ Data0 of - [$y, Result, A, B] -> - case Result of - 0 -> - {alive, Socket, ?u16(A, B)}; - _ -> - {error, duplicate_name} - end; - Data when length(Data) < 4 -> - wait_for_reg_reply(Socket, Data); - Garbage -> - {error, {garbage_from_epmd, Garbage}} - end; - {tcp_closed, Socket} -> - {error, epmd_close} + {tcp, Socket, Data0} -> + case SoFar ++ Data0 of + [$y, Result, A, B] -> + case Result of + 0 -> + {alive, Socket, ?u16(A, B)}; + _ -> + {error, duplicate_name} + end; + Data when length(Data) < 4 -> + wait_for_reg_reply(Socket, Data); + Garbage -> + {error, {garbage_from_epmd, Garbage}} + end; + {tcp_closed, Socket} -> + {error, epmd_close} after 10000 -> - gen_tcp:close(Socket), - {error, no_reg_reply_from_epmd} + gen_tcp:close(Socket), + {error, no_reg_reply_from_epmd} end. register(NodeName, ListenSocket, VLow, VHigh) -> {ok,{_,TcpPort}} = inet:sockname(ListenSocket), case do_register_node(NodeName, TcpPort, VLow, VHigh) of - {alive, Socket, Creation} -> - Socket; - Other -> - exit(Other) + {alive, Socket, _Creation} -> + Socket; + Other -> + exit(Other) end. @@ -618,69 +578,10 @@ split(Atom) -> {A,B} = split(atom_to_list(Atom),[]), {list_to_atom(A),list_to_atom(B)}. -%% Build a simple distribution message -build_message(Cookie) -> - [$?,term_to_binary({6,self(),Cookie,rex}),term_to_binary(plupp)]. - -%% Build a distribution message that will make rex answer -build_rex_message(Cookie,OurName) -> - [$?,term_to_binary({6,self(),Cookie,rex}), - term_to_binary({'$gen_cast', - {cast, - rpc, - cast, - [OurName, hello, world, []], - self()} })]. - -%% Receive a distribution message -recv_message(Socket) -> - case gen_tcp:recv(Socket, 0) of - {ok,Data} -> - B0 = list_to_binary(Data), - {_,B1} = erlang:split_binary(B0,1), - Header = erlang:binary_to_term(B1), - Siz = size(term_to_binary(Header)), - {_,B2} = erlang:split_binary(B1,Siz), - Message = case (catch erlang:binary_to_term(B2)) of - {'EXIT', _} -> - could_not_digest_message; - Other -> - Other - end, - {Header, Message}; - Res -> - exit({no_message,Res}) - end. - %% Build a nodename join(Name,Host) -> list_to_atom(atom_to_list(Name) ++ "@" ++ atom_to_list(Host)). -%% start/stop slave. -start_node(Name, Param) -> - ?t:start_node(Name, slave, [{args, Param}]). - -stop_node(Node) -> - ?t:stop_node(Node). - - -get_nodenames(N, T) -> - get_nodenames(N, T, []). - -get_nodenames(0, _, Acc) -> - Acc; -get_nodenames(N, T, Acc) -> - {A, B, C} = now(), - get_nodenames(N-1, T, [list_to_atom(atom_to_list(?MODULE) - ++ "-" - ++ atom_to_list(T) - ++ "-" - ++ integer_to_list(A) - ++ "-" - ++ integer_to_list(B) - ++ "-" - ++ integer_to_list(C)) | Acc]). - get_epmd_port() -> case init:get_argument(epmd_port) of {ok, [[PortStr|_]|_]} when is_list(PortStr) -> diff --git a/lib/erl_interface/test/erl_connect_SUITE.erl b/lib/erl_interface/test/erl_connect_SUITE.erl index d3fe020bce..f035f1af56 100644 --- a/lib/erl_interface/test/erl_connect_SUITE.erl +++ b/lib/erl_interface/test/erl_connect_SUITE.erl @@ -24,87 +24,64 @@ -include_lib("common_test/include/ct.hrl"). -include("erl_connect_SUITE_data/erl_connect_test_cases.hrl"). --export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - init_per_testcase/2,end_per_testcase/2, - erl_send/1,erl_reg_send/1, erl_send_cookie_file/1]). +-export([all/0, suite/0, + erl_send/1, erl_reg_send/1, + erl_send_cookie_file/1]). -import(runner, [get_term/1,send_term/2]). -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}, + {timetrap, {seconds, 30}}]. all() -> [erl_send, erl_reg_send, erl_send_cookie_file]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - - -init_per_testcase(_Case, Config) -> - Dog = ?t:timetrap(?t:minutes(0.25)), - [{watchdog, Dog}|Config]. - -end_per_testcase(_Case, Config) -> - Dog = ?config(watchdog, Config), - test_server:timetrap_cancel(Dog), - ok. erl_send(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line 1 = erl_connect_init(P, 42, erlang:get_cookie(), 0), - ?line {ok,Fd} = erl_connect(P, node()), + P = runner:start(?interpret), + 1 = erl_connect_init(P, 42, erlang:get_cookie(), 0), + {ok,Fd} = erl_connect(P, node()), - ?line ok = erl_send(P, Fd, self(), AMsg={a,message}), - ?line receive AMsg -> ok end, + ok = erl_send(P, Fd, self(), AMsg={a,message}), + receive AMsg -> ok end, - ?line 0 = erl_close_connection(P,Fd), - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + 0 = erl_close_connection(P,Fd), + runner:send_eot(P), + runner:recv_eot(P), ok. erl_send_cookie_file(Config) when is_list(Config) -> case os:type() of - vxworks -> - {skip,"Skipped on VxWorks"}; - _ -> - ?line P = runner:start(?interpret), - ?line 1 = erl_connect_init(P, 42, '', 0), - ?line {ok,Fd} = erl_connect(P, node()), - - ?line ok = erl_send(P, Fd, self(), AMsg={a,message}), - ?line receive AMsg -> ok end, - - ?line 0 = erl_close_connection(P,Fd), - ?line runner:send_eot(P), - ?line runner:recv_eot(P), - ok + vxworks -> + {skip,"Skipped on VxWorks"}; + _ -> + P = runner:start(?interpret), + 1 = erl_connect_init(P, 42, '', 0), + {ok,Fd} = erl_connect(P, node()), + + ok = erl_send(P, Fd, self(), AMsg={a,message}), + receive AMsg -> ok end, + + 0 = erl_close_connection(P,Fd), + runner:send_eot(P), + runner:recv_eot(P), + ok end. erl_reg_send(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line 1 = erl_connect_init(P, 42, erlang:get_cookie(), 0), - ?line {ok,Fd} = erl_connect(P, node()), + P = runner:start(?interpret), + 1 = erl_connect_init(P, 42, erlang:get_cookie(), 0), + {ok,Fd} = erl_connect(P, node()), ARegName = a_strange_registred_name, - ?line register(ARegName, self()), - ?line ok = erl_reg_send(P, Fd, ARegName, AMsg={another,[strange],message}), - ?line receive AMsg -> ok end, + register(ARegName, self()), + ok = erl_reg_send(P, Fd, ARegName, AMsg={another,[strange],message}), + receive AMsg -> ok end, - ?line 0 = erl_close_connection(P,Fd), - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + 0 = erl_close_connection(P,Fd), + runner:send_eot(P), + runner:recv_eot(P), ok. @@ -113,20 +90,20 @@ erl_reg_send(Config) when is_list(Config) -> erl_connect_init(P, Num, Cookie, Creation) -> send_command(P, erl_connect_init, [Num,Cookie,Creation]), case get_term(P) of - {term,Int} when is_integer(Int) -> Int + {term,Int} when is_integer(Int) -> Int end. erl_connect(P, Node) -> send_command(P, erl_connect, [Node]), case get_term(P) of - {term,{Fd,_}} when Fd >= 0 -> {ok,Fd}; - {term,{-1,Errno}} -> {error,Errno} + {term,{Fd,_}} when Fd >= 0 -> {ok,Fd}; + {term,{-1,Errno}} -> {error,Errno} end. erl_close_connection(P, FD) -> send_command(P, erl_close_connection, [FD]), case get_term(P) of - {term,Int} when is_integer(Int) -> Int + {term,Int} when is_integer(Int) -> Int end. erl_send(P, Fd, To, Msg) -> @@ -139,17 +116,12 @@ erl_reg_send(P, Fd, To, Msg) -> get_send_result(P) -> case get_term(P) of - {term,{1,_}} -> ok; - {term,{-1,Errno}} -> {error,Errno}; - {term,{Res,Errno}}-> - io:format("Return value: ~p\nerl_errno: ~p", [Res,Errno]), - ?t:fail(bad_return_value) + {term,{1,_}} -> ok; + {term,{-1,Errno}} -> {error,Errno}; + {term,{Res,Errno}}-> + io:format("Return value: ~p\nerl_errno: ~p", [Res,Errno]), + ct:fail(bad_return_value) end. send_command(P, Name, Args) -> runner:send_term(P, {Name,list_to_tuple(Args)}). - - - - - diff --git a/lib/erl_interface/test/erl_eterm_SUITE.erl b/lib/erl_interface/test/erl_eterm_SUITE.erl index 230310f63b..b342a2f1ef 100644 --- a/lib/erl_interface/test/erl_eterm_SUITE.erl +++ b/lib/erl_interface/test/erl_eterm_SUITE.erl @@ -34,40 +34,39 @@ %%% 5. Miscellanous functions. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% --export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - build_terms/1, round_trip_conversion/1, - decode_terms/1, decode_float/1, - t_erl_mk_int/1, t_erl_mk_list/1, - basic_copy/1, - t_erl_cons/1, - t_erl_mk_atom/1, - t_erl_mk_binary/1, - t_erl_mk_empty_list/1, - t_erl_mk_float/1, - t_erl_mk_pid/1, - t_erl_mk_xpid/1, - t_erl_mk_port/1, - t_erl_mk_xport/1, - t_erl_mk_ref/1, - t_erl_mk_long_ref/1, - t_erl_mk_string/1, - t_erl_mk_estring/1, - t_erl_mk_tuple/1, - t_erl_mk_uint/1, - t_erl_mk_var/1, - t_erl_size/1, - t_erl_var_content/1, - t_erl_element/1, - t_erl_length/1, t_erl_hd/1, t_erl_tl/1, - type_checks/1, extractor_macros/1, - t_erl_iolist_length/1, t_erl_iolist_to_binary/1, - t_erl_iolist_to_string/1, - erl_print_term/1, print_string/1, - t_erl_free_compound/1, - high_chaparal/1, - broken_data/1, - cnode_1/1]). +-export([all/0, suite/0, + build_terms/1, round_trip_conversion/1, + decode_terms/1, decode_float/1, + t_erl_mk_int/1, t_erl_mk_list/1, + basic_copy/1, + t_erl_cons/1, + t_erl_mk_atom/1, + t_erl_mk_binary/1, + t_erl_mk_empty_list/1, + t_erl_mk_float/1, + t_erl_mk_pid/1, + t_erl_mk_xpid/1, + t_erl_mk_port/1, + t_erl_mk_xport/1, + t_erl_mk_ref/1, + t_erl_mk_long_ref/1, + t_erl_mk_string/1, + t_erl_mk_estring/1, + t_erl_mk_tuple/1, + t_erl_mk_uint/1, + t_erl_mk_var/1, + t_erl_size/1, + t_erl_var_content/1, + t_erl_element/1, + t_erl_length/1, t_erl_hd/1, t_erl_tl/1, + type_checks/1, extractor_macros/1, + t_erl_iolist_length/1, t_erl_iolist_to_binary/1, + t_erl_iolist_to_string/1, + erl_print_term/1, print_string/1, + t_erl_free_compound/1, + high_chaparal/1, + broken_data/1, + cnode_1/1]). -export([start_cnode/1]). @@ -76,7 +75,8 @@ %% This test suite controls the running of the C language functions %% in eterm_test.c and print_term.c. -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}]. all() -> [build_terms, round_trip_conversion, decode_terms, @@ -93,22 +93,6 @@ all() -> erl_print_term, print_string, t_erl_free_compound, high_chaparal, broken_data, cnode_1]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - - %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% @@ -119,82 +103,77 @@ end_per_group(_GroupName, Config) -> %% This test asks the C function to construct all data types in %% a list and verifies that the result is as expected. -build_terms(suite) -> []; build_terms(Config) when is_list(Config) -> - ?line P = runner:start(?build_terms), - ?line {term, Term} = get_term(P), - ?line io:format("Received: ~p", [Term]), - ?line [ARefLN, ARef, APortLN, APort, APidLN, APid, - {element1, 42, 767}, "A string", - 1, -1, 0, 3.0, ABin, 'I am an atom'] = Term, - ?line "A binary" = binary_to_list(ABin), - ?line case ARef of - R when is_reference(R), node(R) == kalle@localhost -> ok - end, - ?line case ARefLN of - R1 when is_reference(R1), node(R1) == abcdefghijabcdefghij@localhost -> ok - end, - ?line case APort of - Port when is_port(Port), node(Port) == kalle@localhost -> ok - end, - ?line case APortLN of - Port1 when is_port(Port1), node(Port1) == abcdefghijabcdefghij@localhost -> ok - end, - ?line case APid of - Pid when is_pid(Pid), node(Pid) == kalle@localhost -> ok - end, - ?line case APidLN of - Pid1 when is_pid(Pid1), node(Pid1) == abcdefghijabcdefghij@localhost -> ok - end, - - ?line runner:recv_eot(P), + P = runner:start(?build_terms), + {term, Term} = get_term(P), + io:format("Received: ~p", [Term]), + [ARefLN, ARef, APortLN, APort, APidLN, APid, + {element1, 42, 767}, "A string", + 1, -1, 0, 3.0, ABin, 'I am an atom'] = Term, + "A binary" = binary_to_list(ABin), + case ARef of + R when is_reference(R), node(R) == kalle@localhost -> ok + end, + case ARefLN of + R1 when is_reference(R1), node(R1) == abcdefghijabcdefghij@localhost -> ok + end, + case APort of + Port when is_port(Port), node(Port) == kalle@localhost -> ok + end, + case APortLN of + Port1 when is_port(Port1), node(Port1) == abcdefghijabcdefghij@localhost -> ok + end, + case APid of + Pid when is_pid(Pid), node(Pid) == kalle@localhost -> ok + end, + case APidLN of + Pid1 when is_pid(Pid1), node(Pid1) == abcdefghijabcdefghij@localhost -> ok + end, + + runner:recv_eot(P), ok. %% This test is run entirely in C code. -round_trip_conversion(suite) -> []; round_trip_conversion(Config) when is_list(Config) -> - ?line runner:test(?round_trip_conversion), + runner:test(?round_trip_conversion), ok. %% This test sends a list of all data types to the C code function, %% which decodes it and verifies it. -decode_terms(suite) -> []; decode_terms(Config) when is_list(Config) -> - ?line Dummy1 = list_to_atom(filename:join(?config(priv_dir, Config), - dummy_file1)), - ?line Dummy2 = list_to_atom(filename:join(?config(priv_dir, Config), - dummy_file2)), - ?line Port1 = open_port(Dummy1, [out]), - ?line Port2 = open_port(Dummy2, [out]), - ?line ABinary = list_to_binary("A binary"), - ?line Terms = [make_ref(), make_ref(), - Port1, Port2, - self(), self(), - {element1, 42, 767}, "A string", - 1, -1, 0, 3.0, ABinary, 'I am an atom'], - - ?line P = runner:start(?decode_terms), - ?line runner:send_term(P, Terms), - ?line runner:recv_eot(P), + Dummy1 = list_to_atom(filename:join(proplists:get_value(priv_dir, Config), + dummy_file1)), + Dummy2 = list_to_atom(filename:join(proplists:get_value(priv_dir, Config), + dummy_file2)), + Port1 = open_port(Dummy1, [out]), + Port2 = open_port(Dummy2, [out]), + ABinary = list_to_binary("A binary"), + Terms = [make_ref(), make_ref(), + Port1, Port2, + self(), self(), + {element1, 42, 767}, "A string", + 1, -1, 0, 3.0, ABinary, 'I am an atom'], + + P = runner:start(?decode_terms), + runner:send_term(P, Terms), + runner:recv_eot(P), ok. %% Decodes the floating point number 3.1415. -decode_float(suite) -> []; decode_float(Config) when is_list(Config) -> - ?line P = runner:start(?decode_float), - ?line runner:send_term(P, 3.1415), - ?line runner:recv_eot(P), + P = runner:start(?decode_float), + runner:send_term(P, 3.1415), + runner:recv_eot(P), ok. %% Tests the erl_free_compound() function. -t_erl_free_compound(suite) -> []; t_erl_free_compound(Config) when is_list(Config) -> - ?line runner:test(?t_erl_free_compound), + runner:test(?t_erl_free_compound), ok. @@ -206,317 +185,296 @@ t_erl_free_compound(Config) when is_list(Config) -> %% This tests the erl_mk_list() function. -t_erl_mk_list(suite) -> []; t_erl_mk_list(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_list), + P = runner:start(?t_erl_mk_list), - ?line {term, []} = get_term(P), - ?line {term, [abc]} = get_term(P), - ?line {term, [abcdef, 42]} = get_term(P), - ?line {term, [0.0, 23, [], 3.1415]} = get_term(P), + {term, []} = get_term(P), + {term, [abc]} = get_term(P), + {term, [abcdef, 42]} = get_term(P), + {term, [0.0, 23, [], 3.1415]} = get_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_mk_int() function. -t_erl_mk_int(suite) -> []; t_erl_mk_int(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_int), - - ?line {term, 0} = get_term(P), - ?line {term, 127} = get_term(P), - ?line {term, 128} = get_term(P), - ?line {term, 255} = get_term(P), - ?line {term, 256} = get_term(P), - - ?line {term, 16#FFFF} = get_term(P), - ?line {term, 16#10000} = get_term(P), - - ?line {term, 16#07FFFFFF} = get_term(P), - ?line {term, 16#0FFFFFFF} = get_term(P), - ?line {term, 16#1FFFFFFF} = get_term(P), - ?line {term, 16#3FFFFFFF} = get_term(P), - ?line {term, 16#7FFFFFFF} = get_term(P), - - ?line {term, 16#08000000} = get_term(P), - ?line {term, 16#10000000} = get_term(P), - ?line {term, 16#20000000} = get_term(P), - ?line {term, 16#40000000} = get_term(P), - - - ?line {term, -16#07FFFFFF} = get_term(P), - ?line {term, -16#0FFFFFFF} = get_term(P), - ?line {term, -16#1FFFFFFF} = get_term(P), - ?line {term, -16#3FFFFFFF} = get_term(P), - ?line {term, -16#7FFFFFFF} = get_term(P), - - ?line {term, -16#08000000} = get_term(P), - ?line {term, -16#10000000} = get_term(P), - ?line {term, -16#20000000} = get_term(P), - ?line {term, -16#40000000} = get_term(P), - - ?line {term, -16#08000001} = get_term(P), - ?line {term, -16#10000001} = get_term(P), - ?line {term, -16#20000001} = get_term(P), - ?line {term, -16#40000001} = get_term(P), - - ?line {term, -16#08000002} = get_term(P), - ?line {term, -16#10000002} = get_term(P), - ?line {term, -16#20000002} = get_term(P), - ?line {term, -16#40000002} = get_term(P), - - ?line {term, -1999999999} = get_term(P), - ?line {term, -2000000000} = get_term(P), - ?line {term, -2000000001} = get_term(P), - - ?line runner:recv_eot(P), + P = runner:start(?t_erl_mk_int), + + {term, 0} = get_term(P), + {term, 127} = get_term(P), + {term, 128} = get_term(P), + {term, 255} = get_term(P), + {term, 256} = get_term(P), + + {term, 16#FFFF} = get_term(P), + {term, 16#10000} = get_term(P), + + {term, 16#07FFFFFF} = get_term(P), + {term, 16#0FFFFFFF} = get_term(P), + {term, 16#1FFFFFFF} = get_term(P), + {term, 16#3FFFFFFF} = get_term(P), + {term, 16#7FFFFFFF} = get_term(P), + + {term, 16#08000000} = get_term(P), + {term, 16#10000000} = get_term(P), + {term, 16#20000000} = get_term(P), + {term, 16#40000000} = get_term(P), + + + {term, -16#07FFFFFF} = get_term(P), + {term, -16#0FFFFFFF} = get_term(P), + {term, -16#1FFFFFFF} = get_term(P), + {term, -16#3FFFFFFF} = get_term(P), + {term, -16#7FFFFFFF} = get_term(P), + + {term, -16#08000000} = get_term(P), + {term, -16#10000000} = get_term(P), + {term, -16#20000000} = get_term(P), + {term, -16#40000000} = get_term(P), + + {term, -16#08000001} = get_term(P), + {term, -16#10000001} = get_term(P), + {term, -16#20000001} = get_term(P), + {term, -16#40000001} = get_term(P), + + {term, -16#08000002} = get_term(P), + {term, -16#10000002} = get_term(P), + {term, -16#20000002} = get_term(P), + {term, -16#40000002} = get_term(P), + + {term, -1999999999} = get_term(P), + {term, -2000000000} = get_term(P), + {term, -2000000001} = get_term(P), + + runner:recv_eot(P), ok. %% Basic test of erl_copy_term(). -basic_copy(suite) -> []; basic_copy(Config) when is_list(Config) -> - ?line runner:test(?basic_copy), + runner:test(?basic_copy), ok. %% This tests the erl_mk_tuple() function. -t_erl_mk_tuple(suite) -> []; t_erl_mk_tuple(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_tuple), + P = runner:start(?t_erl_mk_tuple), - ?line {term, {madonna, 21, 'mad donna', 12}} = get_term(P), - ?line {term, {'Madonna',21,{children,{"Isabella",2}}, - {'home page',"http://www.madonna.com/"}}} = get_term(P), + {term, {madonna, 21, 'mad donna', 12}} = get_term(P), + {term, {'Madonna',21,{children,{"Isabella",2}}, + {'home page',"http://www.madonna.com/"}}} = get_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_mk_atom() function. -t_erl_mk_atom(suite) -> []; t_erl_mk_atom(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_atom), - - ?line {term, madonna} = (get_term(P)), - ?line {term, 'Madonna'} = (get_term(P)), - ?line {term, 'mad donna'} = (get_term(P)), - ?line {term, '_madonna_'} = (get_term(P)), - ?line {term, '/home/madonna/tour_plan'} = (get_term(P)), - ?line {term, 'http://www.madonna.com/tour_plan'} = (get_term(P)), - ?line {term, '\'madonna\''} = (get_term(P)), - ?line {term, '\"madonna\"'} = (get_term(P)), - ?line {term, '\\madonna\\'} = (get_term(P)), - ?line {term, '{madonna,21,\'mad donna\',12}'} = (get_term(P)), - - ?line runner:recv_eot(P), + P = runner:start(?t_erl_mk_atom), + + {term, madonna} = (get_term(P)), + {term, 'Madonna'} = (get_term(P)), + {term, 'mad donna'} = (get_term(P)), + {term, '_madonna_'} = (get_term(P)), + {term, '/home/madonna/tour_plan'} = (get_term(P)), + {term, 'http://www.madonna.com/tour_plan'} = (get_term(P)), + {term, '\'madonna\''} = (get_term(P)), + {term, '\"madonna\"'} = (get_term(P)), + {term, '\\madonna\\'} = (get_term(P)), + {term, '{madonna,21,\'mad donna\',12}'} = (get_term(P)), + + runner:recv_eot(P), ok. %% This tests the erl_mk_binary() function. -t_erl_mk_binary(suite) -> []; t_erl_mk_binary(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_binary), + P = runner:start(?t_erl_mk_binary), - ?line {term, Bin} = (get_term(P)), - ?line "{madonna,21,'mad donna',1234.567.890, !#$%&/()=?+-@, \" \\}" = - binary_to_list(Bin), + {term, Bin} = (get_term(P)), + "{madonna,21,'mad donna',1234.567.890, !#$%&/()=?+-@, \" \\}" = binary_to_list(Bin), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_mk_empty_list() function. -t_erl_mk_empty_list(suite) -> []; t_erl_mk_empty_list(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_empty_list), + P = runner:start(?t_erl_mk_empty_list), - ?line {term, []} = get_term(P), + {term, []} = get_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_mk_float() function. -t_erl_mk_float(suite) -> []; t_erl_mk_float(Config) when is_list(Config) -> case os:type() of - vxworks -> - {skipped, "Floating point numbers never compare equal on PPC"}; - _ -> - ?line P = runner:start(?t_erl_mk_float), - ?line {term, {3.1415, 1.999999, 2.000000, 2.000001, - 2.000002, 12345.67890}} = - get_term(P), - ?line runner:recv_eot(P), - ok + vxworks -> + {skipped, "Floating point numbers never compare equal on PPC"}; + _ -> + P = runner:start(?t_erl_mk_float), + {term, {3.1415, 1.999999, 2.000000, 2.000001, + 2.000002, 12345.67890}} = get_term(P), + runner:recv_eot(P), + ok end. %% This tests the erl_mk_pid() function. -t_erl_mk_pid(suite) -> []; t_erl_mk_pid(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_pid), + P = runner:start(?t_erl_mk_pid), - ?line {term, A_pid} = (get_term(P)), - ?line {pid, kalle@localhost, 3, 2} = nc2vinfo(A_pid), + {term, A_pid} = (get_term(P)), + {pid, kalle@localhost, 3, 2} = nc2vinfo(A_pid), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. -t_erl_mk_xpid(suite) -> []; t_erl_mk_xpid(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_xpid), + P = runner:start(?t_erl_mk_xpid), - ?line {term, A_pid} = (get_term(P)), - ?line {pid, kalle@localhost, 32767, 8191} = nc2vinfo(A_pid), + {term, A_pid} = (get_term(P)), + {pid, kalle@localhost, 32767, 8191} = nc2vinfo(A_pid), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_mk_port() function. -t_erl_mk_port(suite) -> []; t_erl_mk_port(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_port), + P = runner:start(?t_erl_mk_port), - ?line {term, A_port} = (get_term(P)), - ?line {port, kalle@localhost, 4} = nc2vinfo(A_port), + {term, A_port} = (get_term(P)), + {port, kalle@localhost, 4} = nc2vinfo(A_port), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. -t_erl_mk_xport(suite) -> []; t_erl_mk_xport(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_xport), + P = runner:start(?t_erl_mk_xport), - ?line {term, A_port} = (get_term(P)), - ?line {port, kalle@localhost, 268435455} = nc2vinfo(A_port), + {term, A_port} = (get_term(P)), + {port, kalle@localhost, 268435455} = nc2vinfo(A_port), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_mk_ref() function. -t_erl_mk_ref(suite) -> []; t_erl_mk_ref(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_ref), + P = runner:start(?t_erl_mk_ref), - ?line {term, A_ref} = (get_term(P)), - ?line {ref, kalle@localhost, _Length, [6]} = nc2vinfo(A_ref), + {term, A_ref} = (get_term(P)), + {ref, kalle@localhost, _Length, [6]} = nc2vinfo(A_ref), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. -t_erl_mk_long_ref(suite) -> []; t_erl_mk_long_ref(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_long_ref), + P = runner:start(?t_erl_mk_long_ref), - ?line {term, A_ref} = (get_term(P)), - ?line {ref, kalle@localhost, _Length, [4294967295,4294967295,262143]} - = nc2vinfo(A_ref), + {term, A_ref} = (get_term(P)), + {ref, kalle@localhost, _Length, [4294967295,4294967295,262143]} + = nc2vinfo(A_ref), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_mk_string() function. -t_erl_mk_string(suite) -> []; t_erl_mk_string(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_string), - - ?line {term, "madonna"} = (get_term(P)), - ?line {term, "Madonna"} = (get_term(P)), - ?line {term, "mad donna"} = (get_term(P)), - ?line {term, "_madonna_"} = (get_term(P)), - ?line {term, "/home/madonna/tour_plan"} = (get_term(P)), - ?line {term, "http://www.madonna.com/tour_plan"} = (get_term(P)), - ?line {term, "\'madonna\'"} = (get_term(P)), - ?line {term, "\"madonna\""} = (get_term(P)), - ?line {term, "\\madonna\\"} = (get_term(P)), - ?line {term, "{madonna,21,'mad donna',12}"} = (get_term(P)), - - ?line runner:recv_eot(P), + P = runner:start(?t_erl_mk_string), + + {term, "madonna"} = (get_term(P)), + {term, "Madonna"} = (get_term(P)), + {term, "mad donna"} = (get_term(P)), + {term, "_madonna_"} = (get_term(P)), + {term, "/home/madonna/tour_plan"} = (get_term(P)), + {term, "http://www.madonna.com/tour_plan"} = (get_term(P)), + {term, "\'madonna\'"} = (get_term(P)), + {term, "\"madonna\""} = (get_term(P)), + {term, "\\madonna\\"} = (get_term(P)), + {term, "{madonna,21,'mad donna',12}"} = (get_term(P)), + + runner:recv_eot(P), ok. %% This tests the erl_mk_estring() function. -t_erl_mk_estring(suite) -> []; t_erl_mk_estring(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_estring), - - ?line {term, "madonna"} = (get_term(P)), - ?line {term, "Madonna"} = (get_term(P)), - ?line {term, "mad donna"} = (get_term(P)), - ?line {term, "_madonna_"} = (get_term(P)), - ?line {term, "/home/madonna/tour_plan"} = (get_term(P)), - ?line {term, "http://www.madonna.com/tour_plan"} = (get_term(P)), - ?line {term, "\'madonna\'"} = (get_term(P)), - ?line {term, "\"madonna\""} = (get_term(P)), - ?line {term, "\\madonna\\"} = (get_term(P)), - ?line {term, "{madonna,21,'mad donna',12}"} = (get_term(P)), - - ?line runner:recv_eot(P), + P = runner:start(?t_erl_mk_estring), + + {term, "madonna"} = (get_term(P)), + {term, "Madonna"} = (get_term(P)), + {term, "mad donna"} = (get_term(P)), + {term, "_madonna_"} = (get_term(P)), + {term, "/home/madonna/tour_plan"} = (get_term(P)), + {term, "http://www.madonna.com/tour_plan"} = (get_term(P)), + {term, "\'madonna\'"} = (get_term(P)), + {term, "\"madonna\""} = (get_term(P)), + {term, "\\madonna\\"} = (get_term(P)), + {term, "{madonna,21,'mad donna',12}"} = (get_term(P)), + + runner:recv_eot(P), ok. %% This tests the erl_mk_uint() function. -t_erl_mk_uint(suite) -> []; t_erl_mk_uint(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_uint), + P = runner:start(?t_erl_mk_uint), - ?line {term, 54321} = (get_term(P)), - ?line {term, 2147483647} = (get_term(P)), - ?line {term, 2147483648} = (get_term(P)), - ?line {term, 2147483649} = (get_term(P)), - ?line {term, 2147483650} = (get_term(P)), - ?line {term, 4294967295} = (get_term(P)), + {term, 54321} = (get_term(P)), + {term, 2147483647} = (get_term(P)), + {term, 2147483648} = (get_term(P)), + {term, 2147483649} = (get_term(P)), + {term, 2147483650} = (get_term(P)), + {term, 4294967295} = (get_term(P)), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_mk_var() function. -t_erl_mk_var(suite) -> []; t_erl_mk_var(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_mk_var), + P = runner:start(?t_erl_mk_var), - ?line {term, 1} = (get_term(P)), - ?line {term, 0} = (get_term(P)), - ?line {term, 1} = (get_term(P)), - ?line {term, 0} = (get_term(P)), - ?line {term, 1} = (get_term(P)), - ?line {term, 0} = (get_term(P)), - ?line {term, 1} = (get_term(P)), + {term, 1} = (get_term(P)), + {term, 0} = (get_term(P)), + {term, 1} = (get_term(P)), + {term, 0} = (get_term(P)), + {term, 1} = (get_term(P)), + {term, 0} = (get_term(P)), + {term, 1} = (get_term(P)), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_cons() function. -t_erl_cons(suite) -> []; t_erl_cons(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_cons), + P = runner:start(?t_erl_cons), - ?line {term, [madonna, 21]} = get_term(P), + {term, [madonna, 21]} = get_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. @@ -531,21 +489,20 @@ t_erl_cons(Config) when is_list(Config) -> %% Tests the erl_length() function. -t_erl_length(suite) -> []; t_erl_length(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_length), + P = runner:start(?t_erl_length), - ?line 0 = erl_length(P, []), - ?line 1 = erl_length(P, [a]), - ?line 2 = erl_length(P, [a, b]), - ?line 3 = erl_length(P, [a, b, c]), + 0 = erl_length(P, []), + 1 = erl_length(P, [a]), + 2 = erl_length(P, [a, b]), + 3 = erl_length(P, [a, b, c]), - ?line 4 = erl_length(P, [a, [x, y], c, []]), + 4 = erl_length(P, [a, [x, y], c, []]), - ?line -1 = erl_length(P, [a|b]), - ?line -1 = erl_length(P, a), + -1 = erl_length(P, [a|b]), + -1 = erl_length(P, a), - ?line runner:finish(P), + runner:finish(P), ok. %% Invokes the erl_length() function. @@ -555,22 +512,21 @@ erl_length(Port, List) -> %% Tests the erl_hd() function. -t_erl_hd(suite) -> []; t_erl_hd(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_hd), - - ?line 'NULL' = erl_hd(P, 42), - ?line 'NULL' = erl_hd(P, abc), - ?line 'NULL' = erl_hd(P, []), - - ?line [] = erl_hd(P, [[], a]), - ?line a = erl_hd(P, [a]), - ?line a = erl_hd(P, [a, b]), - ?line a = erl_hd(P, [a, b, c]), - ?line a = erl_hd(P, [a|b]), - - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + P = runner:start(?t_erl_hd), + + 'NULL' = erl_hd(P, 42), + 'NULL' = erl_hd(P, abc), + 'NULL' = erl_hd(P, []), + + [] = erl_hd(P, [[], a]), + a = erl_hd(P, [a]), + a = erl_hd(P, [a, b]), + a = erl_hd(P, [a, b, c]), + a = erl_hd(P, [a|b]), + + runner:send_eot(P), + runner:recv_eot(P), ok. %% Invokes the erl_hd() function. @@ -580,22 +536,21 @@ erl_hd(Port, List) -> %% Tests the erl_tail() function. -t_erl_tl(suite) -> []; t_erl_tl(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_tl), + P = runner:start(?t_erl_tl), - ?line 'NULL' = erl_tl(P, 42), - ?line 'NULL' = erl_tl(P, abc), - ?line 'NULL' = erl_tl(P, []), + 'NULL' = erl_tl(P, 42), + 'NULL' = erl_tl(P, abc), + 'NULL' = erl_tl(P, []), - ?line [] = erl_tl(P, [a]), - ?line [b] = erl_tl(P, [a, b]), - ?line [b, c] = erl_tl(P, [a, b, c]), + [] = erl_tl(P, [a]), + [b] = erl_tl(P, [a, b]), + [b, c] = erl_tl(P, [a, b, c]), - ?line b = erl_tl(P, [a|b]), + b = erl_tl(P, [a|b]), - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + runner:send_eot(P), + runner:recv_eot(P), ok. %% Invokes the erl_tail() function in erl_interface. @@ -605,68 +560,63 @@ erl_tl(Port, List) -> %% Tests the type checking macros (done in the C program). -type_checks(suite) -> []; type_checks(Config) when is_list(Config) -> - ?line runner:test(?type_checks), + runner:test(?type_checks), ok. %% Tests the extractor macros (done in the C program). -extractor_macros(suite) -> []; extractor_macros(Config) when is_list(Config) -> - ?line runner:test(?extractor_macros), + runner:test(?extractor_macros), ok. %% This tests the erl_size() function. -t_erl_size(suite) -> []; t_erl_size(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_size), + P = runner:start(?t_erl_size), - ?line {term, 0} = (get_term(P)), - ?line {term, 4} = (get_term(P)), + {term, 0} = (get_term(P)), + {term, 4} = (get_term(P)), - ?line {term, 0} = (get_term(P)), - ?line {term, 27} = (get_term(P)), + {term, 0} = (get_term(P)), + {term, 27} = (get_term(P)), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_var_content() function. -t_erl_var_content(suite) -> []; t_erl_var_content(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_var_content), + P = runner:start(?t_erl_var_content), - ?line {term, 17} = (get_term(P)), - ?line {term, "http://www.madonna.com"} = (get_term(P)), - ?line {term, 2} = (get_term(P)), - ?line {term, "http://www.madonna.com"} = (get_term(P)), - ?line {term, 2} = (get_term(P)), + {term, 17} = (get_term(P)), + {term, "http://www.madonna.com"} = (get_term(P)), + {term, 2} = (get_term(P)), + {term, "http://www.madonna.com"} = (get_term(P)), + {term, 2} = (get_term(P)), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. %% This tests the erl_element() function. -t_erl_element(suite) -> []; t_erl_element(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_element), + P = runner:start(?t_erl_element), - ?line {term, madonna} = get_term(P), - ?line {term, 21} = get_term(P), - ?line {term, 'mad donna'} = get_term(P), - ?line {term, 12} = get_term(P), + {term, madonna} = get_term(P), + {term, 21} = get_term(P), + {term, 'mad donna'} = get_term(P), + {term, 12} = get_term(P), - ?line {term, 'Madonna'} = get_term(P), - ?line {term, 21} = get_term(P), - ?line {term, {children,{"Isabella",2}}} = get_term(P), - ?line {term, {'home page',"http://www.madonna.com/"}} = get_term(P), + {term, 'Madonna'} = get_term(P), + {term, 21} = get_term(P), + {term, {children,{"Isabella",2}}} = get_term(P), + {term, {'home page',"http://www.madonna.com/"}} = get_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. @@ -679,65 +629,64 @@ t_erl_element(Config) when is_list(Config) -> %% Tests the erl_iolist_length() function. -t_erl_iolist_length(suite) -> []; t_erl_iolist_length(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_iolist_length), + P = runner:start(?t_erl_iolist_length), %% Flat lists. - ?line 0 = erl_iolist_length(P, []), - ?line 1 = erl_iolist_length(P, [10]), - ?line 2 = erl_iolist_length(P, [10, 20]), - ?line 3 = erl_iolist_length(P, [10, 20, 30]), - ?line 256 = erl_iolist_length(P, lists:seq(0, 255)), + 0 = erl_iolist_length(P, []), + 1 = erl_iolist_length(P, [10]), + 2 = erl_iolist_length(P, [10, 20]), + 3 = erl_iolist_length(P, [10, 20, 30]), + 256 = erl_iolist_length(P, lists:seq(0, 255)), %% Deep lists. - ?line 0 = erl_iolist_length(P, [[]]), - ?line 1 = erl_iolist_length(P, [[], 42]), - ?line 1 = erl_iolist_length(P, [42, []]), - ?line 2 = erl_iolist_length(P, [42, [], 45]), + 0 = erl_iolist_length(P, [[]]), + 1 = erl_iolist_length(P, [[], 42]), + 1 = erl_iolist_length(P, [42, []]), + 2 = erl_iolist_length(P, [42, [], 45]), - ?line 3 = erl_iolist_length(P, [42, [90], 45]), - ?line 3 = erl_iolist_length(P, [[42, [90]], 45]), - ?line 3 = erl_iolist_length(P, [[42, [90]], 45]), + 3 = erl_iolist_length(P, [42, [90], 45]), + 3 = erl_iolist_length(P, [[42, [90]], 45]), + 3 = erl_iolist_length(P, [[42, [90]], 45]), %% List with binaries. - ?line 0 = erl_iolist_length(P, [list_to_binary([])]), - ?line 0 = erl_iolist_length(P, [[], list_to_binary([])]), - ?line 1 = erl_iolist_length(P, [[1], list_to_binary([])]), - ?line 1 = erl_iolist_length(P, [[], list_to_binary([2])]), - ?line 2 = erl_iolist_length(P, [[42], list_to_binary([2])]), - ?line 4 = erl_iolist_length(P, [[42], list_to_binary([2, 3, 4])]), + 0 = erl_iolist_length(P, [list_to_binary([])]), + 0 = erl_iolist_length(P, [[], list_to_binary([])]), + 1 = erl_iolist_length(P, [[1], list_to_binary([])]), + 1 = erl_iolist_length(P, [[], list_to_binary([2])]), + 2 = erl_iolist_length(P, [[42], list_to_binary([2])]), + 4 = erl_iolist_length(P, [[42], list_to_binary([2, 3, 4])]), %% Binaries as tail. - ?line 0 = erl_iolist_length(P, [[]| list_to_binary([])]), - ?line 1 = erl_iolist_length(P, [[1]| list_to_binary([])]), - ?line 1 = erl_iolist_length(P, [[]| list_to_binary([2])]), - ?line 2 = erl_iolist_length(P, [[42]| list_to_binary([2])]), + 0 = erl_iolist_length(P, [[]| list_to_binary([])]), + 1 = erl_iolist_length(P, [[1]| list_to_binary([])]), + 1 = erl_iolist_length(P, [[]| list_to_binary([2])]), + 2 = erl_iolist_length(P, [[42]| list_to_binary([2])]), %% Binaries only. - ?line 0 = erl_iolist_length(P, list_to_binary("")), - ?line 1 = erl_iolist_length(P, list_to_binary([1])), - ?line 2 = erl_iolist_length(P, list_to_binary([1, 2])), + 0 = erl_iolist_length(P, list_to_binary("")), + 1 = erl_iolist_length(P, list_to_binary([1])), + 2 = erl_iolist_length(P, list_to_binary([1, 2])), %% Illegal cases. - ?line -1 = erl_iolist_length(P, [42|43]), - ?line -1 = erl_iolist_length(P, a), + -1 = erl_iolist_length(P, [42|43]), + -1 = erl_iolist_length(P, a), - ?line -1 = erl_iolist_length(P, [a]), - ?line -1 = erl_iolist_length(P, [256]), - ?line -1 = erl_iolist_length(P, [257]), - ?line -1 = erl_iolist_length(P, [-1]), - ?line -1 = erl_iolist_length(P, [-2]), - ?line -1 = erl_iolist_length(P, [-127]), - ?line -1 = erl_iolist_length(P, [-128]), + -1 = erl_iolist_length(P, [a]), + -1 = erl_iolist_length(P, [256]), + -1 = erl_iolist_length(P, [257]), + -1 = erl_iolist_length(P, [-1]), + -1 = erl_iolist_length(P, [-2]), + -1 = erl_iolist_length(P, [-127]), + -1 = erl_iolist_length(P, [-128]), - ?line runner:finish(P), + runner:finish(P), ok. %% Invokes the erl_iolist_length() function. @@ -747,143 +696,141 @@ erl_iolist_length(Port, List) -> %% Tests the erl_iolist_to_binary() function. -t_erl_iolist_to_binary(suite) -> []; t_erl_iolist_to_binary(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_iolist_to_binary), + P = runner:start(?t_erl_iolist_to_binary), %% Flat lists. - ?line [] = iolist_to_list(P, []), - ?line [10] = iolist_to_list(P, [10]), - ?line [10, 20] = iolist_to_list(P, [10, 20]), - ?line [10, 20, 30] = iolist_to_list(P, [10, 20, 30]), - ?line AllBytes = lists:seq(0, 255), - ?line AllBytes = iolist_to_list(P, AllBytes), + [] = iolist_to_list(P, []), + [10] = iolist_to_list(P, [10]), + [10, 20] = iolist_to_list(P, [10, 20]), + [10, 20, 30] = iolist_to_list(P, [10, 20, 30]), + AllBytes = lists:seq(0, 255), + AllBytes = iolist_to_list(P, AllBytes), %% Deep lists. - ?line [] = iolist_to_list(P, [[]]), - ?line [42] = iolist_to_list(P, [[], 42]), - ?line [42] = iolist_to_list(P, [42, []]), - ?line [42, 45] = iolist_to_list(P, [42, [], 45]), + [] = iolist_to_list(P, [[]]), + [42] = iolist_to_list(P, [[], 42]), + [42] = iolist_to_list(P, [42, []]), + [42, 45] = iolist_to_list(P, [42, [], 45]), - ?line [42, 90, 45] = iolist_to_list(P, [42, [90], 45]), - ?line [42, 90, 45] = iolist_to_list(P, [[42, [90]], 45]), - ?line [42, 90, 45] = iolist_to_list(P, [[42, [90]], 45]), + [42, 90, 45] = iolist_to_list(P, [42, [90], 45]), + [42, 90, 45] = iolist_to_list(P, [[42, [90]], 45]), + [42, 90, 45] = iolist_to_list(P, [[42, [90]], 45]), %% List with binaries. - ?line [] = iolist_to_list(P, [list_to_binary([])]), - ?line [] = iolist_to_list(P, [[], list_to_binary([])]), - ?line [1] = iolist_to_list(P, [[1], list_to_binary([])]), - ?line [2] = iolist_to_list(P, [[], list_to_binary([2])]), - ?line [42, 2] = iolist_to_list(P, [[42], list_to_binary([2])]), - ?line [42, 2, 3, 4] = iolist_to_list(P, [[42], list_to_binary([2, 3, 4])]), + [] = iolist_to_list(P, [list_to_binary([])]), + [] = iolist_to_list(P, [[], list_to_binary([])]), + [1] = iolist_to_list(P, [[1], list_to_binary([])]), + [2] = iolist_to_list(P, [[], list_to_binary([2])]), + [42, 2] = iolist_to_list(P, [[42], list_to_binary([2])]), + [42, 2, 3, 4] = iolist_to_list(P, [[42], list_to_binary([2, 3, 4])]), %% Binaries as tail. - ?line [] = iolist_to_list(P, [[]| list_to_binary([])]), - ?line [1] = iolist_to_list(P, [[1]| list_to_binary([])]), - ?line [2] = iolist_to_list(P, [[]| list_to_binary([2])]), - ?line [42, 2] = iolist_to_list(P, [[42]| list_to_binary([2])]), + [] = iolist_to_list(P, [[]| list_to_binary([])]), + [1] = iolist_to_list(P, [[1]| list_to_binary([])]), + [2] = iolist_to_list(P, [[]| list_to_binary([2])]), + [42, 2] = iolist_to_list(P, [[42]| list_to_binary([2])]), %% Binaries only. - ?line [] = iolist_to_list(P, list_to_binary("")), - ?line [1] = iolist_to_list(P, list_to_binary([1])), - ?line [1, 2] = iolist_to_list(P, list_to_binary([1, 2])), + [] = iolist_to_list(P, list_to_binary("")), + [1] = iolist_to_list(P, list_to_binary([1])), + [1, 2] = iolist_to_list(P, list_to_binary([1, 2])), %% Illegal cases. - ?line 'NULL' = iolist_to_list(P, [42|43]), - ?line 'NULL' = iolist_to_list(P, a), + 'NULL' = iolist_to_list(P, [42|43]), + 'NULL' = iolist_to_list(P, a), - ?line 'NULL' = iolist_to_list(P, [a]), - ?line 'NULL' = iolist_to_list(P, [256]), - ?line 'NULL' = iolist_to_list(P, [257]), - ?line 'NULL' = iolist_to_list(P, [-1]), - ?line 'NULL' = iolist_to_list(P, [-2]), - ?line 'NULL' = iolist_to_list(P, [-127]), - ?line 'NULL' = iolist_to_list(P, [-128]), + 'NULL' = iolist_to_list(P, [a]), + 'NULL' = iolist_to_list(P, [256]), + 'NULL' = iolist_to_list(P, [257]), + 'NULL' = iolist_to_list(P, [-1]), + 'NULL' = iolist_to_list(P, [-2]), + 'NULL' = iolist_to_list(P, [-127]), + 'NULL' = iolist_to_list(P, [-128]), - ?line runner:finish(P), + runner:finish(P), ok. iolist_to_list(Port, Term) -> case call_erl_function(Port, Term) of - 'NULL' -> - 'NULL'; - Bin when is_binary(Bin) -> - binary_to_list(Bin) + 'NULL' -> + 'NULL'; + Bin when is_binary(Bin) -> + binary_to_list(Bin) end. %% Tests the erl_iolist_to_string() function. -t_erl_iolist_to_string(suite) -> []; t_erl_iolist_to_string(Config) when is_list(Config) -> - ?line P = runner:start(?t_erl_iolist_to_string), + P = runner:start(?t_erl_iolist_to_string), %% Flat lists. - ?line [0] = iolist_to_string(P, []), - ?line [10, 0] = iolist_to_string(P, [10]), - ?line [10, 20, 0] = iolist_to_string(P, [10, 20]), - ?line [10, 20, 30, 0] = iolist_to_string(P, [10, 20, 30]), - ?line AllBytes = lists:seq(1, 255)++[0], - ?line AllBytes = iolist_to_string(P, lists:seq(1, 255)), + [0] = iolist_to_string(P, []), + [10, 0] = iolist_to_string(P, [10]), + [10, 20, 0] = iolist_to_string(P, [10, 20]), + [10, 20, 30, 0] = iolist_to_string(P, [10, 20, 30]), + AllBytes = lists:seq(1, 255)++[0], + AllBytes = iolist_to_string(P, lists:seq(1, 255)), %% Deep lists. - ?line [0] = iolist_to_string(P, [[]]), - ?line [42, 0] = iolist_to_string(P, [[], 42]), - ?line [42, 0] = iolist_to_string(P, [42, []]), - ?line [42, 45, 0] = iolist_to_string(P, [42, [], 45]), + [0] = iolist_to_string(P, [[]]), + [42, 0] = iolist_to_string(P, [[], 42]), + [42, 0] = iolist_to_string(P, [42, []]), + [42, 45, 0] = iolist_to_string(P, [42, [], 45]), - ?line [42, 90, 45, 0] = iolist_to_string(P, [42, [90], 45]), - ?line [42, 90, 45, 0] = iolist_to_string(P, [[42, [90]], 45]), - ?line [42, 90, 45, 0] = iolist_to_string(P, [[42, [90]], 45]), + [42, 90, 45, 0] = iolist_to_string(P, [42, [90], 45]), + [42, 90, 45, 0] = iolist_to_string(P, [[42, [90]], 45]), + [42, 90, 45, 0] = iolist_to_string(P, [[42, [90]], 45]), %% List with binaries. - ?line [0] = iolist_to_string(P, [list_to_binary([])]), - ?line [0] = iolist_to_string(P, [[], list_to_binary([])]), - ?line [1, 0] = iolist_to_string(P, [[1], list_to_binary([])]), - ?line [2, 0] = iolist_to_string(P, [[], list_to_binary([2])]), - ?line [42, 2, 0] = iolist_to_string(P, [[42], list_to_binary([2])]), - ?line [42, 2, 3, 4, 0] = iolist_to_string(P, [[42], - list_to_binary([2, 3, 4])]), + [0] = iolist_to_string(P, [list_to_binary([])]), + [0] = iolist_to_string(P, [[], list_to_binary([])]), + [1, 0] = iolist_to_string(P, [[1], list_to_binary([])]), + [2, 0] = iolist_to_string(P, [[], list_to_binary([2])]), + [42, 2, 0] = iolist_to_string(P, [[42], list_to_binary([2])]), + [42, 2, 3, 4, 0] = iolist_to_string(P, [[42], + list_to_binary([2, 3, 4])]), %% Binaries as tail. - ?line [0] = iolist_to_string(P, [[]| list_to_binary([])]), - ?line [1, 0] = iolist_to_string(P, [[1]| list_to_binary([])]), - ?line [2, 0] = iolist_to_string(P, [[]| list_to_binary([2])]), - ?line [42, 2, 0] = iolist_to_string(P, [[42]| list_to_binary([2])]), + [0] = iolist_to_string(P, [[]| list_to_binary([])]), + [1, 0] = iolist_to_string(P, [[1]| list_to_binary([])]), + [2, 0] = iolist_to_string(P, [[]| list_to_binary([2])]), + [42, 2, 0] = iolist_to_string(P, [[42]| list_to_binary([2])]), %% Binaries only. - ?line [0] = iolist_to_string(P, list_to_binary("")), - ?line [1, 0] = iolist_to_string(P, list_to_binary([1])), - ?line [1, 2, 0] = iolist_to_string(P, list_to_binary([1, 2])), + [0] = iolist_to_string(P, list_to_binary("")), + [1, 0] = iolist_to_string(P, list_to_binary([1])), + [1, 2, 0] = iolist_to_string(P, list_to_binary([1, 2])), %% Illegal cases. - ?line 'NULL' = iolist_to_string(P, [0]), - ?line 'NULL' = iolist_to_string(P, [65, 0, 66]), - ?line 'NULL' = iolist_to_string(P, [65, 66, 67, 0]), + 'NULL' = iolist_to_string(P, [0]), + 'NULL' = iolist_to_string(P, [65, 0, 66]), + 'NULL' = iolist_to_string(P, [65, 66, 67, 0]), - ?line 'NULL' = iolist_to_string(P, [42|43]), - ?line 'NULL' = iolist_to_string(P, a), + 'NULL' = iolist_to_string(P, [42|43]), + 'NULL' = iolist_to_string(P, a), - ?line 'NULL' = iolist_to_string(P, [a]), - ?line 'NULL' = iolist_to_string(P, [256]), - ?line 'NULL' = iolist_to_string(P, [257]), - ?line 'NULL' = iolist_to_string(P, [-1]), - ?line 'NULL' = iolist_to_string(P, [-2]), - ?line 'NULL' = iolist_to_string(P, [-127]), - ?line 'NULL' = iolist_to_string(P, [-128]), + 'NULL' = iolist_to_string(P, [a]), + 'NULL' = iolist_to_string(P, [256]), + 'NULL' = iolist_to_string(P, [257]), + 'NULL' = iolist_to_string(P, [-1]), + 'NULL' = iolist_to_string(P, [-2]), + 'NULL' = iolist_to_string(P, [-127]), + 'NULL' = iolist_to_string(P, [-128]), - ?line runner:finish(P), + runner:finish(P), ok. %% Invokes the erl_iolist_to_string() function. @@ -891,8 +838,8 @@ t_erl_iolist_to_string(Config) when is_list(Config) -> iolist_to_string(Port, Term) -> runner:send_term(Port, Term), case get_term(Port) of - {bytes, Result} -> Result; - 'NULL' -> 'NULL' + {bytes, Result} -> Result; + 'NULL' -> 'NULL' end. @@ -902,38 +849,37 @@ iolist_to_string(Port, Term) -> %%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -erl_print_term(suite) -> []; -erl_print_term(doc) -> "Tests the erl_print_term() function"; +%% Tests the erl_print_term() function erl_print_term(Config) when is_list(Config) -> - ?line PrintTerm = print_term(Config), - ?line P = open_port({spawn, PrintTerm}, [stream]), + PrintTerm = print_term(Config), + P = open_port({spawn, PrintTerm}, [stream]), %% Lists. - ?line print(P, "[]", []), - ?line print(P, "[a]", [a]), - ?line print(P, "[[a]]", [[a]]), - ?line print(P, "[[]]", [[]]), - ?line print(P, "[a,b,c]", [a,b,c]), - ?line print(P, "[a,b|c]", [a,b|c]), - ?line print(P, "[a,[],c]", [a,[],c]), - ?line print(P, "[a,[1000,1],c]", [a,[1000,1],c]), + print(P, "[]", []), + print(P, "[a]", [a]), + print(P, "[[a]]", [[a]]), + print(P, "[[]]", [[]]), + print(P, "[a,b,c]", [a,b,c]), + print(P, "[a,b|c]", [a,b|c]), + print(P, "[a,[],c]", [a,[],c]), + print(P, "[a,[1000,1],c]", [a,[1000,1],c]), %% Tuples. - ?line print(P, "{}", {}), - ?line print(P, "{ok}", {ok}), - ?line print(P, "{1,2,3}", {1, 2, 3}), + print(P, "{}", {}), + print(P, "{ok}", {ok}), + print(P, "{1,2,3}", {1, 2, 3}), %% Pids. - ?line {_X, Y, Z} = split_pid(self()), - ?line PidString = lists:flatten(io_lib:format("<~s.~w.~w>", - [node(), Y, Z])), - ?line print(P, PidString, self()), + {_X, Y, Z} = split_pid(self()), + PidString = lists:flatten(io_lib:format("<~s.~w.~w>", + [node(), Y, Z])), + print(P, PidString, self()), - ?line unlink(P), - ?line exit(P, die), + unlink(P), + exit(P, die), ok. split_pid(Pid) when is_pid(Pid) -> @@ -948,23 +894,22 @@ split_pid([$.|Rest], Cur, Result) -> split_pid([$>], Cur, Result) -> list_to_tuple(Result++[Cur]). -print_string(suite) -> []; -print_string(doc) -> "Test printing a string with erl_print_term()"; +%% Test printing a string with erl_print_term() print_string(Config) when is_list(Config) -> - ?line PrintTerm = print_term(Config), - ?line P = open_port({spawn, PrintTerm}, [stream]), + PrintTerm = print_term(Config), + P = open_port({spawn, PrintTerm}, [stream]), %% Strings. - ?line print(P, "\"ABC\"", "ABC"), - ?line {11, "\"\\tABC\\r\\n\""} = print(P, "\tABC\r\n"), + print(P, "\"ABC\"", "ABC"), + {11, "\"\\tABC\\r\\n\""} = print(P, "\tABC\r\n"), %% Not strings. - ?line print(P, "[65,66,67,0]", "ABC\000"), + print(P, "[65,66,67,0]", "ABC\000"), - ?line unlink(P), - ?line exit(P, die), + unlink(P), + exit(P, die), ok. print(Port, TermString, Term) -> @@ -983,15 +928,16 @@ print(Port, Term) -> collect_line(Port, Result) -> receive - {Port, {data, Data}} -> - case lists:reverse(Data) of - [$\n|Rest] -> - collect_line1(Rest++Result, []); - Chars -> - collect_line(Port, Chars++Result) - end - after test_server:seconds(5) -> - test_server:fail("No response from C program") + {Port, {data, Data}} -> + case lists:reverse(Data) of + [$\n|Rest] -> + collect_line1(Rest++Result, []); + Chars -> + collect_line(Port, Chars++Result) + end + after 5000 -> + test_server:fail("No response from C program") + ct:fail("No response from C program") end. collect_line1([$\r|Rest], Result) -> @@ -1001,18 +947,16 @@ collect_line1([C|Rest], Result) -> %% Test case submitted by Per Lundgren, ERV. -high_chaparal(suite) -> []; high_chaparal(Config) when is_list(Config) -> - ?line P = runner:start(?high_chaparal), - ?line {term, [hello, world]} = get_term(P), - ?line runner:recv_eot(P), + P = runner:start(?high_chaparal), + {term, [hello, world]} = get_term(P), + runner:recv_eot(P), ok. %% OTP-7448 -broken_data(suite) -> []; broken_data(Config) when is_list(Config) -> - ?line P = runner:start(?broken_data), - ?line runner:recv_eot(P), + P = runner:start(?broken_data), + runner:recv_eot(P), ok. %% This calls a C function with one parameter and returns the result. @@ -1020,12 +964,12 @@ broken_data(Config) when is_list(Config) -> call_erl_function(Port, Term) -> runner:send_term(Port, Term), case get_term(Port) of - {term, Result} -> Result; - 'NULL' -> 'NULL' + {term, Result} -> Result; + 'NULL' -> 'NULL' end. print_term(Config) when is_list(Config) -> - filename:join(?config(data_dir, Config), "print_term"). + filename:join(proplists:get_value(data_dir, Config), "print_term"). @@ -1034,57 +978,57 @@ print_term(Config) when is_list(Config) -> %%% back, without having been mutated into short form. We must take %%% care then to check the actual returned ref, and not the original %%% one, which is equal to it. -cnode_1(suite) -> []; -cnode_1(doc) -> "Tests involving cnode: sends a long ref from a cnode to us"; + +%% Tests involving cnode: sends a long ref from a cnode to us cnode_1(Config) when is_list(Config) -> - ?line Cnode = filename:join(?config(data_dir, Config), "cnode"), - ?line register(mip, self()), - ?line spawn_link(?MODULE, start_cnode, [Cnode]), - ?line Ref1 = get_ref(), + Cnode = filename:join(proplists:get_value(data_dir, Config), "cnode"), + register(mip, self()), + spawn_link(?MODULE, start_cnode, [Cnode]), + Ref1 = get_ref(), io:format("Ref1 ~p~n", [Ref1]), - ?line check_ref(Ref1), - ?line Ref2 = make_ref(), - ?line receive - Pid -> Pid - end, - ?line Fun1 = fun(X) -> {Pid, X} end, % sneak in a fun test here - %?line Fun1 = {wait_with_funs, new_dist_format}, - ?line Term = {Ref2, Fun1, {1,2,3,4,5,6,7,8,9,10}}, + check_ref(Ref1), + Ref2 = make_ref(), + Pid = receive + Msg -> Msg %% pid + end, + Fun1 = fun(X) -> {Pid, X} end, % sneak in a fun test here + %Fun1 = {wait_with_funs, new_dist_format}, + Term = {Ref2, Fun1, {1,2,3,4,5,6,7,8,9,10}}, %% A term which will overflow the original buffer used in 'cnode'. - ?line Pid ! Term, - ?line receive - Term2 -> - io:format("received ~p~n", [Term2]), - case Term2 of - Term -> - {Ref22,_,_} = Term2, - ?line check_ref(Ref22); - X -> - test_server:fail({receive1,X}) - end - after 5000 -> - test_server:fail(receive1) - end, - ?line receive - Pid -> - ok; - Y -> - test_server:fail({receive1,Y}) - after 5000 -> - test_server:fail(receive2) - end, - ?line io:format("ref = ~p~n", [Ref1]), - ?line check_ref(Ref1), + Pid ! Term, + receive + Term2 -> + io:format("received ~p~n", [Term2]), + case Term2 of + Term -> + {Ref22,_,_} = Term2, + check_ref(Ref22); + X -> + ct:fail({receive1,X}) + end + after 5000 -> + ct:fail(receive1) + end, + receive + Pid -> + ok; + Y -> + ct:fail({receive1,Y}) + after 5000 -> + ct:fail(receive2) + end, + io:format("ref = ~p~n", [Ref1]), + check_ref(Ref1), ok. check_ref(Ref) -> case bin_ext_type(Ref) of - 101 -> - test_server:fail(oldref); - 114 -> - ok; - Type -> - test_server:fail({type, Type}) + 101 -> + ct:fail(oldref); + 114 -> + ok; + Type -> + ct:fail({type, Type}) end. bin_ext_type(T) -> @@ -1093,10 +1037,10 @@ bin_ext_type(T) -> get_ref() -> receive - X when is_reference(X) -> - X + X when is_reference(X) -> + X after 5000 -> - test_server:fail({cnode, timeout}) + ct:fail({cnode, timeout}) end. start_cnode(Cnode) -> @@ -1105,35 +1049,33 @@ start_cnode(Cnode) -> rec_cnode() -> receive - X -> - io:format("from cnode: ~p~n", [X]), - rec_cnode() + X -> + io:format("from cnode: ~p~n", [X]), + rec_cnode() end. nc2vinfo(Pid) when is_pid(Pid) -> - ?line [_NodeStr, NumberStr, SerialStr] - = string:tokens(pid_to_list(Pid), "<.>"), - ?line Number = list_to_integer(NumberStr), - ?line Serial = list_to_integer(SerialStr), - ?line {pid, node(Pid), Number, Serial}; + [_NodeStr, NumberStr, SerialStr] + = string:tokens(pid_to_list(Pid), "<.>"), + Number = list_to_integer(NumberStr), + Serial = list_to_integer(SerialStr), + {pid, node(Pid), Number, Serial}; nc2vinfo(Port) when is_port(Port) -> - ?line ["#Port", _NodeStr, NumberStr] - = string:tokens(erlang:port_to_list(Port), "<.>"), - ?line Number = list_to_integer(NumberStr), - ?line {port, node(Port), Number}; + ["#Port", _NodeStr, NumberStr] + = string:tokens(erlang:port_to_list(Port), "<.>"), + Number = list_to_integer(NumberStr), + {port, node(Port), Number}; nc2vinfo(Ref) when is_reference(Ref) -> - ?line ["#Ref", _NodeStr | NumStrList] - = string:tokens(erlang:ref_to_list(Ref), "<.>"), - ?line {Len, RevNumList} = lists:foldl(fun ("0", {N, []}) -> - {N+1, []}; - (IStr, {N, Is}) -> - {N+1, - [list_to_integer(IStr)|Is]} - end, - {0, []}, - NumStrList), - ?line {ref, node(Ref), Len, lists:reverse(RevNumList)}; + ["#Ref", _NodeStr | NumStrList] + = string:tokens(erlang:ref_to_list(Ref), "<.>"), + {Len, RevNumList} = lists:foldl(fun ("0", {N, []}) -> + {N+1, []}; + (IStr, {N, Is}) -> + {N+1, + [list_to_integer(IStr)|Is]} + end, + {0, []}, + NumStrList), + {ref, node(Ref), Len, lists:reverse(RevNumList)}; nc2vinfo(Other) -> - ?line {badarg, Other}. - - + {badarg, Other}. diff --git a/lib/erl_interface/test/erl_ext_SUITE.erl b/lib/erl_interface/test/erl_ext_SUITE.erl index cbc93b4cfb..9b2f3d3017 100644 --- a/lib/erl_interface/test/erl_ext_SUITE.erl +++ b/lib/erl_interface/test/erl_ext_SUITE.erl @@ -24,74 +24,44 @@ -include_lib("common_test/include/ct.hrl"). -include("erl_ext_SUITE_data/ext_test_cases.hrl"). --export([ - all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - compare_tuple/1, - compare_list/1, - compare_string/1, - compare_list_string/1, - compare_nc_ext/1 - ]). +-export([all/0, suite/0, + compare_tuple/1, + compare_list/1, + compare_string/1, + compare_list_string/1, + compare_nc_ext/1]). -import(runner, [get_term/1]). -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}]. all() -> [compare_tuple, compare_list, compare_string, compare_list_string, compare_nc_ext]. -groups() -> - []. -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - - -compare_tuple(suite) -> []; -compare_tuple(doc) -> []; compare_tuple(Config) when is_list(Config) -> - ?line P = runner:start(?compare_tuple), - ?line runner:recv_eot(P), + P = runner:start(?compare_tuple), + runner:recv_eot(P), ok. -compare_list(suite) -> []; -compare_list(doc) -> []; compare_list(Config) when is_list(Config) -> - ?line P = runner:start(?compare_list), - ?line runner:recv_eot(P), + P = runner:start(?compare_list), + runner:recv_eot(P), ok. -compare_string(suite) -> []; -compare_string(doc) -> []; compare_string(Config) when is_list(Config) -> - ?line P = runner:start(?compare_string), - ?line runner:recv_eot(P), + P = runner:start(?compare_string), + runner:recv_eot(P), ok. -compare_list_string(suite) -> []; -compare_list_string(doc) -> []; compare_list_string(Config) when is_list(Config) -> - ?line P = runner:start(?compare_list_string), - ?line runner:recv_eot(P), + P = runner:start(?compare_list_string), + runner:recv_eot(P), ok. -compare_nc_ext(suite) -> []; -compare_nc_ext(doc) -> []; compare_nc_ext(Config) when is_list(Config) -> - ?line P = runner:start(?compare_nc_ext), - ?line runner:recv_eot(P), + P = runner:start(?compare_nc_ext), + runner:recv_eot(P), ok. - - - diff --git a/lib/erl_interface/test/erl_format_SUITE.erl b/lib/erl_interface/test/erl_format_SUITE.erl index afbbe6a241..32b0571f5e 100644 --- a/lib/erl_interface/test/erl_format_SUITE.erl +++ b/lib/erl_interface/test/erl_format_SUITE.erl @@ -24,134 +24,108 @@ -include_lib("common_test/include/ct.hrl"). -include("erl_format_SUITE_data/format_test_cases.hrl"). --export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, atoms/1, tuples/1, lists/1]). +-export([all/0, suite/0, + atoms/1, tuples/1, lists/1]). -import(runner, [get_term/1]). %% This test suite test the erl_format() function. %% It uses the port program "format_test". -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}]. all() -> [atoms, tuples, lists]. -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - - %% Tests formatting various atoms. -atoms(suite) -> []; atoms(Config) when is_list(Config) -> - ?line P = runner:start(?atoms), - - ?line {term, ''} = get_term(P), - ?line {term, 'a'} = get_term(P), - ?line {term, 'A'} = get_term(P), - ?line {term, 'abc'} = get_term(P), - ?line {term, 'Abc'} = get_term(P), - ?line {term, 'ab@c'} = get_term(P), - ?line {term, 'The rain in Spain stays mainly in the plains'} = - get_term(P), - - ?line {term, a} = get_term(P), - ?line {term, ab} = get_term(P), - ?line {term, abc} = get_term(P), - ?line {term, ab@c} = get_term(P), - ?line {term, abcdefghijklmnopq} = get_term(P), - - ?line {term, ''} = get_term(P), - ?line {term, 'a'} = get_term(P), - ?line {term, 'A'} = get_term(P), - ?line {term, 'abc'} = get_term(P), - ?line {term, 'Abc'} = get_term(P), - ?line {term, 'ab@c'} = get_term(P), - ?line {term, 'The rain in Spain stays mainly in the plains'} = - get_term(P), - - ?line {term, a} = get_term(P), - ?line {term, ab} = get_term(P), - ?line {term, abc} = get_term(P), - ?line {term, ab@c} = get_term(P), - ?line {term, ' abcdefghijklmnopq '} = get_term(P), - - ?line runner:recv_eot(P), + P = runner:start(?atoms), + + {term, ''} = get_term(P), + {term, 'a'} = get_term(P), + {term, 'A'} = get_term(P), + {term, 'abc'} = get_term(P), + {term, 'Abc'} = get_term(P), + {term, 'ab@c'} = get_term(P), + {term, 'The rain in Spain stays mainly in the plains'} = get_term(P), + + {term, a} = get_term(P), + {term, ab} = get_term(P), + {term, abc} = get_term(P), + {term, ab@c} = get_term(P), + {term, abcdefghijklmnopq} = get_term(P), + + {term, ''} = get_term(P), + {term, 'a'} = get_term(P), + {term, 'A'} = get_term(P), + {term, 'abc'} = get_term(P), + {term, 'Abc'} = get_term(P), + {term, 'ab@c'} = get_term(P), + {term, 'The rain in Spain stays mainly in the plains'} = get_term(P), + + {term, a} = get_term(P), + {term, ab} = get_term(P), + {term, abc} = get_term(P), + {term, ab@c} = get_term(P), + {term, ' abcdefghijklmnopq '} = get_term(P), + + runner:recv_eot(P), ok. %% Tests formatting various tuples -tuples(suite) -> []; tuples(Config) when is_list(Config) -> - ?line P = runner:start(?tuples), - - ?line {term, {}} = get_term(P), - ?line {term, {a}} = get_term(P), - ?line {term, {a, b}} = get_term(P), - ?line {term, {a, b, c}} = get_term(P), - ?line {term, {1}} = get_term(P), - ?line {term, {[]}} = get_term(P), - ?line {term, {[], []}} = get_term(P), - ?line {term, {[], a, b, c}} = get_term(P), - ?line {term, {[], a, [], b, c}} = get_term(P), - ?line {term, {[], a, '', b, c}} = get_term(P), - - ?line runner:recv_eot(P), + P = runner:start(?tuples), + + {term, {}} = get_term(P), + {term, {a}} = get_term(P), + {term, {a, b}} = get_term(P), + {term, {a, b, c}} = get_term(P), + {term, {1}} = get_term(P), + {term, {[]}} = get_term(P), + {term, {[], []}} = get_term(P), + {term, {[], a, b, c}} = get_term(P), + {term, {[], a, [], b, c}} = get_term(P), + {term, {[], a, '', b, c}} = get_term(P), + + runner:recv_eot(P), ok. %% Tests formatting various lists -lists(suite) -> []; lists(Config) when is_list(Config) -> - ?line P = runner:start(?lists), - - ?line {term, []} = get_term(P), - ?line {term, [a]} = get_term(P), - ?line {term, [a, b]} = get_term(P), - ?line {term, [a, b, c]} = get_term(P), - ?line {term, [1]} = get_term(P), - ?line {term, [[]]} = get_term(P), - ?line {term, [[], []]} = get_term(P), - ?line {term, [[], a, b, c]} = get_term(P), - ?line {term, [[], a, [], b, c]} = get_term(P), - ?line {term, [[], a, '', b, c]} = get_term(P), - - ?line {term, [{name, 'Madonna'}, {age, 21}, {data, [{addr, "E-street", 42}]}]} = - get_term(P), + P = runner:start(?lists), + + {term, []} = get_term(P), + {term, [a]} = get_term(P), + {term, [a, b]} = get_term(P), + {term, [a, b, c]} = get_term(P), + {term, [1]} = get_term(P), + {term, [[]]} = get_term(P), + {term, [[], []]} = get_term(P), + {term, [[], a, b, c]} = get_term(P), + {term, [[], a, [], b, c]} = get_term(P), + {term, [[], a, '', b, c]} = get_term(P), + + {term, [{name, 'Madonna'}, {age, 21}, {data, [{addr, "E-street", 42}]}]} = get_term(P), case os:type() of - vxworks -> - ?line {term, [{pi, _}, {'cos(70)', _}]} = get_term(P), - ?line {term, [[pi, _], ['cos(70)', _]]} = get_term(P), - ?line {term, [[pi, _], [], ["cos(70)", _]]} = - get_term(P); - _ -> - ?line {term, [{pi, 3.1415}, {'cos(70)', 0.34202}]} = get_term(P), - ?line {term, [[pi, 3.1415], ['cos(70)', 0.34202]]} = get_term(P), - ?line {term, [[pi, 3.1415], [], ["cos(70)", 0.34202]]} = - get_term(P) + vxworks -> + {term, [{pi, _}, {'cos(70)', _}]} = get_term(P), + {term, [[pi, _], ['cos(70)', _]]} = get_term(P), + {term, [[pi, _], [], ["cos(70)", _]]} = get_term(P); + _ -> + {term, [{pi, 3.1415}, {'cos(70)', 0.34202}]} = get_term(P), + {term, [[pi, 3.1415], ['cos(70)', 0.34202]]} = get_term(P), + {term, [[pi, 3.1415], [], ["cos(70)", 0.34202]]} = get_term(P) end, - ?line {term, [-1]} = get_term(P), + {term, [-1]} = get_term(P), - ?line runner:recv_eot(P), + runner:recv_eot(P), ok. - - - diff --git a/lib/erl_interface/test/erl_global_SUITE.erl b/lib/erl_interface/test/erl_global_SUITE.erl index 493ad576c9..cf0ec80f66 100644 --- a/lib/erl_interface/test/erl_global_SUITE.erl +++ b/lib/erl_interface/test/erl_global_SUITE.erl @@ -24,9 +24,9 @@ -include_lib("common_test/include/ct.hrl"). -include("erl_global_SUITE_data/erl_global_test_cases.hrl"). --export([all/0,suite/0,init_per_suite/1,end_per_suite/1, - init_per_testcase/2,end_per_testcase/2, - erl_global_registration/1, erl_global_whereis/1, erl_global_names/1]). +-export([all/0,suite/0, + erl_global_registration/1, + erl_global_whereis/1, erl_global_names/1]). -import(runner, [get_term/1,send_term/2]). @@ -35,62 +35,50 @@ all() -> [erl_global_registration, erl_global_whereis, erl_global_names]. -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}, + {timetrap, {seconds, 30}}]. -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_testcase(_Case, Config) -> - Dog = ?t:timetrap(?t:minutes(0.25)), - [{watchdog, Dog}|Config]. - -end_per_testcase(_Case, Config) -> - Dog = ?config(watchdog, Config), - test_server:timetrap_cancel(Dog), - ok. erl_global_registration(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line {ok, Fd} = erl_connect(P, node(), 42, erlang:get_cookie(), 0), + P = runner:start(?interpret), + {ok, Fd} = erl_connect(P, node(), 42, erlang:get_cookie(), 0), - ?line ok = erl_global_register(P, Fd, ?GLOBAL_NAME), - ?line ok = erl_global_unregister(P, Fd, ?GLOBAL_NAME), + ok = erl_global_register(P, Fd, ?GLOBAL_NAME), + ok = erl_global_unregister(P, Fd, ?GLOBAL_NAME), - ?line 0 = erl_close_connection(P,Fd), - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + 0 = erl_close_connection(P,Fd), + runner:send_eot(P), + runner:recv_eot(P), ok. erl_global_whereis(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line {ok, Fd} = erl_connect(P, node(), 42, erlang:get_cookie(), 0), - - ?line Self = self(), - ?line yes = global:register_name(?GLOBAL_NAME, Self), - ?line Self = erl_global_whereis(P, Fd, ?GLOBAL_NAME), - ?line global:unregister_name(?GLOBAL_NAME), - ?line 0 = erl_close_connection(P, Fd), - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + P = runner:start(?interpret), + {ok, Fd} = erl_connect(P, node(), 42, erlang:get_cookie(), 0), + + Self = self(), + yes = global:register_name(?GLOBAL_NAME, Self), + Self = erl_global_whereis(P, Fd, ?GLOBAL_NAME), + global:unregister_name(?GLOBAL_NAME), + 0 = erl_close_connection(P, Fd), + runner:send_eot(P), + runner:recv_eot(P), ok. erl_global_names(Config) when is_list(Config) -> - ?line P = runner:start(?interpret), - ?line {ok, Fd} = erl_connect(P, node(), 42, erlang:get_cookie(), 0), - - ?line Self = self(), - ?line global:register_name(?GLOBAL_NAME, Self), - ?line {Names1, _N1} = erl_global_names(P, Fd), - ?line true = lists:member(atom_to_list(?GLOBAL_NAME), Names1), - ?line global:unregister_name(?GLOBAL_NAME), - ?line {Names2, _N2} = erl_global_names(P, Fd), - ?line false = lists:member(atom_to_list(?GLOBAL_NAME), Names2), - ?line 0 = erl_close_connection(P, Fd), - ?line runner:send_eot(P), - ?line runner:recv_eot(P), + P = runner:start(?interpret), + {ok, Fd} = erl_connect(P, node(), 42, erlang:get_cookie(), 0), + + Self = self(), + global:register_name(?GLOBAL_NAME, Self), + {Names1, _N1} = erl_global_names(P, Fd), + true = lists:member(atom_to_list(?GLOBAL_NAME), Names1), + global:unregister_name(?GLOBAL_NAME), + {Names2, _N2} = erl_global_names(P, Fd), + false = lists:member(atom_to_list(?GLOBAL_NAME), Names2), + 0 = erl_close_connection(P, Fd), + runner:send_eot(P), + runner:recv_eot(P), ok. %%% Interface functions for erl_interface functions. @@ -98,14 +86,14 @@ erl_global_names(Config) when is_list(Config) -> erl_connect(P, Node, Num, Cookie, Creation) -> send_command(P, erl_connect, [Num, Node, Cookie, Creation]), case get_term(P) of - {term,{Fd,_}} when Fd >= 0 -> {ok,Fd}; - {term,{-1,Errno}} -> {error,Errno} + {term,{Fd,_}} when Fd >= 0 -> {ok,Fd}; + {term,{-1,Errno}} -> {error,Errno} end. erl_close_connection(P, FD) -> send_command(P, erl_close_connection, [FD]), case get_term(P) of - {term,Int} when is_integer(Int) -> Int + {term,Int} when is_integer(Int) -> Int end. erl_global_register(P, Fd, Name) -> @@ -115,15 +103,15 @@ erl_global_register(P, Fd, Name) -> erl_global_whereis(P, Fd, Name) -> send_command(P, erl_global_whereis, [Fd,Name]), case get_term(P) of - {term, What} -> - What + {term, What} -> + What end. erl_global_names(P, Fd) -> send_command(P, erl_global_names, [Fd]), case get_term(P) of - {term, What} -> - What + {term, What} -> + What end. erl_global_unregister(P, Fd, Name) -> @@ -132,11 +120,11 @@ erl_global_unregister(P, Fd, Name) -> get_send_result(P) -> case get_term(P) of - {term,{1,_}} -> ok; - {term,{0, 0}} -> ok; - {term,{-1, Errno}} -> {error,Errno}; - {term,{_,_}}-> - ?t:fail(bad_return_value) + {term,{1,_}} -> ok; + {term,{0, 0}} -> ok; + {term,{-1, Errno}} -> {error,Errno}; + {term,{_,_}}-> + ct:fail(bad_return_value) end. send_command(P, Name, Args) -> diff --git a/lib/erl_interface/test/erl_match_SUITE.erl b/lib/erl_interface/test/erl_match_SUITE.erl index ecdebad212..5a40c19e3b 100644 --- a/lib/erl_interface/test/erl_match_SUITE.erl +++ b/lib/erl_interface/test/erl_match_SUITE.erl @@ -24,246 +24,218 @@ -include_lib("common_test/include/ct.hrl"). -include("erl_match_SUITE_data/match_test_cases.hrl"). --export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, - init_per_group/2,end_per_group/2, - atoms/1, lists/1, tuples/1, references/1, pids/1, ports/1, - bind/1, integers/1, floats/1, binaries/1, strings/1]). +-export([all/0, suite/0, + atoms/1, lists/1, tuples/1, references/1, pids/1, ports/1, + bind/1, integers/1, floats/1, binaries/1, strings/1]). %% For interactive running of matcher. -export([start_matcher/1, erl_match/3]). %% This test suite tests the erl_match() function. -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}]. all() -> [atoms, lists, tuples, references, pids, ports, bind, integers, floats, binaries, strings]. -groups() -> - []. -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. - - -atoms(suite) -> []; atoms(Config) when is_list(Config) -> - ?line P = start_matcher(Config), + P = start_matcher(Config), - ?line eq(P, '', ''), - ?line eq(P, a, a), - ?line ne(P, a, b), - ?line ne(P, a, aa), - ?line eq(P, kalle, kalle), - ?line ne(P, kalle, arne), + eq(P, '', ''), + eq(P, a, a), + ne(P, a, b), + ne(P, a, aa), + eq(P, kalle, kalle), + ne(P, kalle, arne), - ?line ne(P, kalle, 42), - ?line ne(P, 42, kalle), + ne(P, kalle, 42), + ne(P, 42, kalle), - ?line runner:finish(P), + runner:finish(P), ok. -lists(suite) -> []; lists(Config) when is_list(Config) -> - ?line P = start_matcher(Config), - ?line eq(P, [], []), + P = start_matcher(Config), + eq(P, [], []), - ?line ne(P, [], [a]), - ?line ne(P, [a], []), + ne(P, [], [a]), + ne(P, [a], []), - ?line eq(P, [a], [a]), - ?line ne(P, [a], [b]), + eq(P, [a], [a]), + ne(P, [a], [b]), - ?line eq(P, [a|b], [a|b]), - ?line ne(P, [a|b], [a|x]), + eq(P, [a|b], [a|b]), + ne(P, [a|b], [a|x]), - ?line eq(P, [a, b], [a, b]), - ?line ne(P, [a, b], [a, x]), + eq(P, [a, b], [a, b]), + ne(P, [a, b], [a, x]), - ?line eq(P, [a, b, c], [a, b, c]), - ?line ne(P, [a, b|c], [a, b|x]), - ?line ne(P, [a, b, c], [a, b, x]), - ?line ne(P, [a, b|c], [a, b|x]), - ?line ne(P, [a, x|c], [a, b|c]), - ?line ne(P, [a, b, c], [a, x, c]), + eq(P, [a, b, c], [a, b, c]), + ne(P, [a, b|c], [a, b|x]), + ne(P, [a, b, c], [a, b, x]), + ne(P, [a, b|c], [a, b|x]), + ne(P, [a, x|c], [a, b|c]), + ne(P, [a, b, c], [a, x, c]), - ?line runner:finish(P), + runner:finish(P), ok. -tuples(suite) -> []; tuples(Config) when is_list(Config) -> - ?line P = start_matcher(Config), + P = start_matcher(Config), - ?line ne(P, {}, {a, b}), - ?line ne(P, {a, b}, {}), - ?line ne(P, {a}, {a, b}), - ?line ne(P, {a, b}, {a}), + ne(P, {}, {a, b}), + ne(P, {a, b}, {}), + ne(P, {a}, {a, b}), + ne(P, {a, b}, {a}), - ?line eq(P, {}, {}), + eq(P, {}, {}), - ?line eq(P, {a}, {a}), - ?line ne(P, {a}, {b}), + eq(P, {a}, {a}), + ne(P, {a}, {b}), - ?line eq(P, {1}, {1}), - ?line ne(P, {1}, {2}), + eq(P, {1}, {1}), + ne(P, {1}, {2}), - ?line eq(P, {a, b}, {a, b}), - ?line ne(P, {x, b}, {a, b}), + eq(P, {a, b}, {a, b}), + ne(P, {x, b}, {a, b}), - ?line ne(P, {error, x}, {error, y}), - ?line ne(P, {error, {undefined, {subscriber, last}}}, - {error, {undefined, {subscriber, name}}}), + ne(P, {error, x}, {error, y}), + ne(P, {error, {undefined, {subscriber, last}}}, + {error, {undefined, {subscriber, name}}}), - ?line runner:finish(P), + runner:finish(P), ok. -references(suite) -> []; references(Config) when is_list(Config) -> - ?line P = start_matcher(Config), - ?line Ref1 = make_ref(), - ?line Ref2 = make_ref(), - - ?line eq(P, Ref1, Ref1), - ?line eq(P, Ref2, Ref2), - ?line ne(P, Ref1, Ref2), - ?line ne(P, Ref2, Ref1), - - ?line runner:finish(P), + P = start_matcher(Config), + Ref1 = make_ref(), + Ref2 = make_ref(), + + eq(P, Ref1, Ref1), + eq(P, Ref2, Ref2), + ne(P, Ref1, Ref2), + ne(P, Ref2, Ref1), + + runner:finish(P), ok. -pids(suite) -> []; pids(Config) when is_list(Config) -> - ?line P = start_matcher(Config), - ?line Pid1 = c:pid(0,1,2), - ?line Pid2 = c:pid(0,1,3), - - ?line eq(P, self(), self()), - ?line eq(P, Pid1, Pid1), - ?line ne(P, Pid1, self()), - ?line ne(P, Pid2, Pid1), - - ?line runner:finish(P), + P = start_matcher(Config), + Pid1 = c:pid(0,1,2), + Pid2 = c:pid(0,1,3), + + eq(P, self(), self()), + eq(P, Pid1, Pid1), + ne(P, Pid1, self()), + ne(P, Pid2, Pid1), + + runner:finish(P), ok. -ports(suite) -> []; ports(Config) when is_list(Config) -> case os:type() of - vxworks -> - {skipped,"not on vxworks, pucko"}; - _ -> - ?line P = start_matcher(Config), - ?line P2 = start_matcher(Config), - - ?line eq(P, P, P), - ?line ne(P, P, P2), - - ?line runner:finish(P), - ?line runner:finish(P2), - ok + vxworks -> + {skipped,"not on vxworks, pucko"}; + _ -> + P = start_matcher(Config), + P2 = start_matcher(Config), + + eq(P, P, P), + ne(P, P, P2), + + runner:finish(P), + runner:finish(P2), + ok end. -integers(suite) -> []; integers(Config) when is_list(Config) -> - ?line P = start_matcher(Config), - ?line I1 = 123, - ?line I2 = 12345, - ?line I3 = -123, - ?line I4 = 2234, - - ?line eq(P, I1, I1), - ?line eq(P, I2, I2), - ?line ne(P, I1, I2), - ?line ne(P, I1, I3), - ?line eq(P, I4, I4), - - ?line runner:finish(P), + P = start_matcher(Config), + I1 = 123, + I2 = 12345, + I3 = -123, + I4 = 2234, + + eq(P, I1, I1), + eq(P, I2, I2), + ne(P, I1, I2), + ne(P, I1, I3), + eq(P, I4, I4), + + runner:finish(P), ok. -floats(suite) -> []; floats(Config) when is_list(Config) -> - ?line P = start_matcher(Config), - ?line F1 = 3.1414, - ?line F2 = 3.1415, - ?line F3 = 3.1416, - - ?line S1 = "string", - ?line S2 = "string2", - - ?line eq(P, F1, F1), - ?line eq(P, F2, F2), - ?line ne(P, F1, F2), - ?line ne(P, F3, F2), - - ?line eq(P, S2, S2), - ?line ne(P, S1, S2), - - ?line runner:finish(P), + P = start_matcher(Config), + F1 = 3.1414, + F2 = 3.1415, + F3 = 3.1416, + + S1 = "string", + S2 = "string2", + + eq(P, F1, F1), + eq(P, F2, F2), + ne(P, F1, F2), + ne(P, F3, F2), + + eq(P, S2, S2), + ne(P, S1, S2), + + runner:finish(P), ok. -binaries(suite) -> []; binaries(Config) when is_list(Config) -> - ?line P = start_matcher(Config), - ?line Bin1 = term_to_binary({kalle, 146015, {kungsgatan, 23}}), - ?line Bin2 = term_to_binary(sune), - ?line Bin3 = list_to_binary("sune"), - - ?line eq(P, Bin1, Bin1), - ?line eq(P, Bin2, Bin2), - ?line eq(P, Bin3, Bin3), - ?line ne(P, Bin1, Bin2), - ?line ne(P, Bin1, Bin3), - ?line ne(P, Bin2, Bin3), - - ?line runner:finish(P), + P = start_matcher(Config), + Bin1 = term_to_binary({kalle, 146015, {kungsgatan, 23}}), + Bin2 = term_to_binary(sune), + Bin3 = list_to_binary("sune"), + + eq(P, Bin1, Bin1), + eq(P, Bin2, Bin2), + eq(P, Bin3, Bin3), + ne(P, Bin1, Bin2), + ne(P, Bin1, Bin3), + ne(P, Bin2, Bin3), + + runner:finish(P), ok. - -strings(suite) -> []; strings(Config) when is_list(Config) -> - ?line P = start_matcher(Config), + P = start_matcher(Config), - ?line S1 = "string", - ?line S2 = "streng", - ?line S3 = "String", - - ?line eq(P, S1, S1), - ?line ne(P, S1, S2), - ?line ne(P, S1, S3), + S1 = "string", + S2 = "streng", + S3 = "String", - ?line runner:finish(P), - ok. + eq(P, S1, S1), + ne(P, S1, S2), + ne(P, S1, S3), + runner:finish(P), + ok. -bind(suite) -> []; bind(Config) when is_list(Config) -> - ?line P = start_bind(Config), - ?line S = "[X,Y,Z]", - ?line L1 = [301,302,302], - ?line L2 = [65,66,67], - - ?line bind_ok(P, S, L1), - ?line bind_ok(P, S, L2), - - ?line runner:finish(P), + P = start_bind(Config), + S = "[X,Y,Z]", + L1 = [301,302,302], + L2 = [65,66,67], + + bind_ok(P, S, L1), + bind_ok(P, S, L2), + + runner:finish(P), ok. start_bind(Config) -> @@ -279,15 +251,12 @@ erl_bind(Port, Pattern, Term) -> Port ! {self(), {command, [$b, Pattern, 0]}}, runner:send_term(Port, Term), case runner:get_term(Port) of - {term, 0} -> false; - {term, 1} -> true + {term, 0} -> false; + {term, 1} -> true end. - - - start_matcher(Config) -> runner:start(?erl_match_server). @@ -303,8 +272,6 @@ erl_match(Port, Pattern, Term) -> runner:send_term(Port, Pattern), runner:send_term(Port, Term), case runner:get_term(Port) of - {term, 0} -> false; - {term, 1} -> true + {term, 0} -> false; + {term, 1} -> true end. - - diff --git a/lib/erl_interface/test/port_call_SUITE.erl b/lib/erl_interface/test/port_call_SUITE.erl index 3bc1a03eab..26e1e0eeb4 100644 --- a/lib/erl_interface/test/port_call_SUITE.erl +++ b/lib/erl_interface/test/port_call_SUITE.erl @@ -32,96 +32,78 @@ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% --export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, init_per_group/2,end_per_group/2, basic/1]). +-export([all/0, suite/0, basic/1]). + % Private exports -include_lib("common_test/include/ct.hrl"). - -suite() -> [{ct_hooks,[ts_install_cth]}]. +suite() -> + [{ct_hooks,[ts_install_cth]}, + {timetrap, {seconds, 10}}]. all() -> -[basic]. - -groups() -> - []. - -init_per_suite(Config) -> - Config. - -end_per_suite(_Config) -> - ok. - -init_per_group(_GroupName, Config) -> - Config. - -end_per_group(_GroupName, Config) -> - Config. + [basic]. -basic(suite) -> []; basic(Config) when is_list(Config) -> case os:type() of - {unix, linux} -> - do_basic(Config); - {unix, sunos} -> - do_basic(Config); - {win32,_} -> - do_basic(Config); - _ -> - {skipped, "Dynamic linking and erl_interface not fully examined" - " on this platform..."} + {unix, linux} -> + do_basic(Config); + {unix, sunos} -> + do_basic(Config); + {win32,_} -> + do_basic(Config); + _ -> + {skipped, "Dynamic linking and erl_interface not fully examined" + " on this platform..."} end. do_basic(Config) -> - ?line Dog = test_server:timetrap(test_server:seconds(10)), - ?line Path = ?config(data_dir, Config), + Path = proplists:get_value(data_dir, Config), - ?line erl_ddll:start(), + erl_ddll:start(), %% Load the echo driver and verify that it was loaded. {ok,L1,L2}=load_port_call_driver(Path), %% Verify that the driver works. - ?line Port = open_port({spawn, port_call_drv}, [eof]), - ?line {hej, "hopp",4711,123445567436543653} = - erlang:port_call(Port,{hej, "hopp",4711,123445567436543653}), - ?line {hej, "hopp",4711,123445567436543653} = - erlang:port_call(Port,0,{hej, "hopp",4711,123445567436543653}), - ?line {[], a, [], b, c} = - erlang:port_call(Port,1,{hej, "hopp",4711,123445567436543653}), - ?line {return, {[], a, [], b, c}} = - erlang:port_call(Port,2,{[], a, [], b, c}), - ?line List = lists:duplicate(200,5), - ?line {return, List} = erlang:port_call(Port,2,List), - ?line {'EXIT',{badarg,_}} = (catch erlang:port_call(Port,4711,[])), - ?line {'EXIT',{badarg,_}} = (catch erlang:port_call(sune,2,[])), - ?line register(gunnar,Port), - ?line {return, List} = erlang:port_call(gunnar,2,List), - ?line {return, a} = erlang:port_call(gunnar,2,a), - ?line erlang:port_close(Port), + Port = open_port({spawn, port_call_drv}, [eof]), + {hej, "hopp",4711,123445567436543653} = + erlang:port_call(Port,{hej, "hopp",4711,123445567436543653}), + {hej, "hopp",4711,123445567436543653} = + erlang:port_call(Port,0,{hej, "hopp",4711,123445567436543653}), + {[], a, [], b, c} = + erlang:port_call(Port,1,{hej, "hopp",4711,123445567436543653}), + {return, {[], a, [], b, c}} = + erlang:port_call(Port,2,{[], a, [], b, c}), + List = lists:duplicate(200,5), + {return, List} = erlang:port_call(Port,2,List), + {'EXIT',{badarg,_}} = (catch erlang:port_call(Port,4711,[])), + {'EXIT',{badarg,_}} = (catch erlang:port_call(sune,2,[])), + register(gunnar,Port), + {return, List} = erlang:port_call(gunnar,2,List), + {return, a} = erlang:port_call(gunnar,2,a), + erlang:port_close(Port), %% Unload the driver and verify that it was unloaded. ok=unload_port_call_driver(L1,L2), - ?line {error, {already_started, _}} = erl_ddll:start(), - ?line ok = erl_ddll:stop(), - - ?line test_server:timetrap_cancel(Dog), + {error, {already_started, _}} = erl_ddll:start(), + ok = erl_ddll:stop(), ok. load_port_call_driver(Path) -> - ?line {ok, L1} = erl_ddll:loaded_drivers(), - ?line ok = erl_ddll:load_driver(Path, port_call_drv), - ?line {ok, L2} = erl_ddll:loaded_drivers(), - ?line ["port_call_drv"] = ordsets:to_list(ordsets:subtract(ordsets:from_list(L2), - ordsets:from_list(L1))), + {ok, L1} = erl_ddll:loaded_drivers(), + ok = erl_ddll:load_driver(Path, port_call_drv), + {ok, L2} = erl_ddll:loaded_drivers(), + ["port_call_drv"] = ordsets:to_list(ordsets:subtract(ordsets:from_list(L2), + ordsets:from_list(L1))), {ok,L1,L2}. unload_port_call_driver(L1,L2) -> - ?line {ok, L2} = erl_ddll:loaded_drivers(), - ?line ok = erl_ddll:unload_driver(port_call_drv), - ?line {ok, L3} = erl_ddll:loaded_drivers(), - ?line [] = ordsets:to_list(ordsets:subtract(ordsets:from_list(L3), - ordsets:from_list(L1))), + {ok, L2} = erl_ddll:loaded_drivers(), + ok = erl_ddll:unload_driver(port_call_drv), + {ok, L3} = erl_ddll:loaded_drivers(), + [] = ordsets:to_list(ordsets:subtract(ordsets:from_list(L3), + ordsets:from_list(L1))), ok. - diff --git a/lib/erl_interface/test/runner.erl b/lib/erl_interface/test/runner.erl index ae2598abf8..3854981ad1 100644 --- a/lib/erl_interface/test/runner.erl +++ b/lib/erl_interface/test/runner.erl @@ -25,7 +25,7 @@ start/1, send_term/2, finish/1, send_eot/1, recv_eot/1, get_term/1, get_term/2]). --define(default_timeout, test_server:seconds(5)). +-define(default_timeout, 5000). %% Executes a test case in a C program. %% @@ -45,7 +45,7 @@ test(Tc, Timeout) -> io:format("In this test case, a success/failure result was"), io:format("expected from the C program.\n"), io:format("Received: ~p", [Other]), - test_server:fail() + ct:fail(badresult) end. %% Executes a test case in a C program. Returns the port. @@ -80,7 +80,7 @@ send_eot(Port) when is_port(Port) -> Port ! {self(), {command, [$e]}}. %% Waits for an 'eot' indication from the C program. -%% Either returns 'ok' or invokes test_server:fail(). +%% Either returns 'ok' or invokes ct:fail(badresult). recv_eot(Port) when is_port(Port) -> case get_term(Port) of @@ -90,12 +90,12 @@ recv_eot(Port) when is_port(Port) -> io:format("Error finishing test case. Expected eof from"), io:format("C program, but got:"), io:format("~p", [Other]), - test_server:fail() + ct:fail(badresult) end. %% Reads a term from the C program. %% -%% Returns: {term, Term}|eot|'NULL' or calls test_server:fail/1,2. +%% Returns: {term, Term}|eot|'NULL' or calls ct:fail/1,2. get_term(Port) -> get_term(Port, ?default_timeout). @@ -105,9 +105,9 @@ get_term(Port, Timeout) -> [$b|Bytes] -> {bytes, Bytes}; [$f] -> - test_server:fail(); + ct:fail(failure); [$f|Reason] -> - test_server:fail(Reason); + ct:fail(Reason); [$t|Term] -> {term, binary_to_term(list_to_binary(Term))}; [$N] -> @@ -119,7 +119,7 @@ get_term(Port, Timeout) -> get_term(Port, Timeout); Other -> io:format("Garbage received from C program: ~p", [Other]), - test_server:fail("Illegal response from C program") + ct:fail("Illegal response from C program") end. get_reply(Port, Timeout) when is_port(Port) -> @@ -127,5 +127,5 @@ get_reply(Port, Timeout) when is_port(Port) -> {Port, {data, Reply}} -> Reply after Timeout -> - test_server:fail("No response from C program") + ct:fail("No response from C program") end. diff --git a/lib/hipe/icode/hipe_icode_fp.erl b/lib/hipe/icode/hipe_icode_fp.erl index 5ae0395b72..ae12f20cc2 100644 --- a/lib/hipe/icode/hipe_icode_fp.erl +++ b/lib/hipe/icode/hipe_icode_fp.erl @@ -34,13 +34,37 @@ -include("hipe_icode.hrl"). -include("../flow/cfg.hrl"). --record(state, {edge_map = gb_trees:empty() :: gb_trees:tree(), - fp_ebb_map = gb_trees:empty() :: gb_trees:tree(), - cfg :: #cfg{}}). +-type mapped_fvar() :: icode_fvar() | {assigned, icode_fvar()} . +-type incoming_fvars() :: [{icode_lbl(), mapped_fvar()}]. +-type initial_var_map() :: #{icode_var() => incoming_fvars()}. +-type bb_phi_list() :: [{icode_fvar(), [{icode_lbl(), icode_fvar()}]}]. +-type var_map_phi() :: #{phi => bb_phi_list(), + icode_var() => mapped_fvar()}. +-type var_map() :: #{icode_var() => mapped_fvar()}. + +-type edge() :: {icode_lbl(), icode_lbl()}. +-type edge_map() :: #{edge() => var_map()}. + +-type worklist(Item) :: {[Item], [Item], gb_sets:set(Item)}. +-type worklist() :: worklist(icode_lbl()). + +-type fail_lbl() :: [] | icode_lbl(). +-type in_block() :: {true, fail_lbl()} | false. +-type fp_ebb_map() :: #{{inblock_in | inblock_out, icode_lbl()} | edge() + => in_block()}. + +-record(state, {edge_map = #{} :: edge_map(), + fp_ebb_map = #{} :: fp_ebb_map(), + cfg :: cfg()}). +-type state() :: #state{}. + +-type icode_phi() :: #icode_phi{}. +-type icode_variable() :: #icode_variable{}. +-type icode_const() :: #icode_const{}. %%-------------------------------------------------------------------- --spec cfg(#cfg{}) -> #cfg{}. +-spec cfg(cfg()) -> cfg(). cfg(Cfg) -> %%hipe_icode_cfg:pp(Cfg), @@ -59,10 +83,14 @@ cfg(Cfg) -> %% corresponding fcheckerror. %%-------------------------------------------------------------------- +-spec annotate_fclearerror(cfg()) -> cfg(). + annotate_fclearerror(Cfg) -> Labels = hipe_icode_cfg:reverse_postorder(Cfg), annotate_fclearerror(Labels, Cfg). +-spec annotate_fclearerror([icode_lbl()], cfg()) -> cfg(). + annotate_fclearerror([Label|Left], Cfg) -> BB = hipe_icode_cfg:bb(Cfg, Label), Code = hipe_bb:code(BB), @@ -73,6 +101,9 @@ annotate_fclearerror([Label|Left], Cfg) -> annotate_fclearerror([], Cfg) -> Cfg. +-spec annotate_fclearerror1(icode_instrs(), icode_lbl(), cfg(), icode_instrs()) + -> icode_instrs(). + annotate_fclearerror1([I|Left], Label, Cfg, Acc) -> case I of #icode_call{} -> @@ -90,6 +121,9 @@ annotate_fclearerror1([I|Left], Label, Cfg, Acc) -> annotate_fclearerror1([], _Label, _Cfg, Acc) -> lists:reverse(Acc). +-spec lookahead_for_fcheckerror(icode_instrs(), icode_lbl(), cfg()) -> + fail_lbl(). + lookahead_for_fcheckerror([I|Left], Label, Cfg) -> case I of #icode_call{} -> @@ -111,10 +145,14 @@ lookahead_for_fcheckerror([], Label, Cfg) -> lookahead_for_fcheckerror(Code, Succ, Cfg) end. +-spec unannotate_fclearerror(cfg()) -> cfg(). + unannotate_fclearerror(Cfg) -> Labels = hipe_icode_cfg:reverse_postorder(Cfg), unannotate_fclearerror(Labels, Cfg). +-spec unannotate_fclearerror([icode_lbl()], cfg()) -> cfg(). + unannotate_fclearerror([Label|Left], Cfg) -> BB = hipe_icode_cfg:bb(Cfg, Label), Code = hipe_bb:code(BB), @@ -125,6 +163,9 @@ unannotate_fclearerror([Label|Left], Cfg) -> unannotate_fclearerror([], Cfg) -> Cfg. +-spec unannotate_fclearerror1(icode_instrs(), icode_instrs()) -> + icode_instrs(). + unannotate_fclearerror1([I|Left], Acc) -> case I of #icode_call{} -> @@ -145,10 +186,14 @@ unannotate_fclearerror1([], Acc) -> %% Make float EBBs %%-------------------------------------------------------------------- +-spec place_fp_blocks(state()) -> state(). + place_fp_blocks(State) -> WorkList = new_worklist(State), transform_block(WorkList, State). +-spec transform_block(worklist(), state()) -> state(). + transform_block(WorkList, State) -> case get_work(WorkList) of none -> @@ -182,6 +227,10 @@ transform_block(WorkList, State) -> end end. +-spec update_maps(state(), icode_lbl(), ordsets:ordset(icode_lbl()), + var_map(), ordsets:ordset(icode_lbl()), var_map()) + -> fixpoint | {state(), [icode_lbl()]}. + update_maps(State, Label, SuccSet, SuccMap, FailSet, FailMap) -> {NewState, Add1} = update_maps(State, Label, SuccSet, SuccMap, []), case update_maps(NewState, Label, FailSet, FailMap, Add1) of @@ -189,6 +238,10 @@ update_maps(State, Label, SuccSet, SuccMap, FailSet, FailMap) -> {_NewState1, _Add} = Ret -> Ret end. +-spec update_maps(state(), icode_lbl(), ordsets:ordset(icode_lbl()), + var_map(), [icode_lbl()]) + -> {state(), [icode_lbl()]}. + update_maps(State, From, [To|Left], Map, Acc) -> case state__map_update(State, From, To, Map) of fixpoint -> @@ -199,10 +252,13 @@ update_maps(State, From, [To|Left], Map, Acc) -> update_maps(State, _From, [], _Map, Acc) -> {State, Acc}. +-spec transform_instrs(icode_instrs(), edge_map(), var_map(), icode_instrs()) + -> {var_map(), icode_instrs()}. + transform_instrs([I|Left], PhiMap, Map, Acc) -> Defines = hipe_icode:defines(I), - NewMap = delete_all(Defines, Map), - NewPhiMap = delete_all(Defines, PhiMap), + NewMap = maps:without(Defines, Map), + NewPhiMap = maps:without(Defines, PhiMap), case I of #icode_phi{} -> Uses = hipe_icode:uses(I), @@ -214,7 +270,7 @@ transform_instrs([I|Left], PhiMap, Map, Acc) -> %% All arguments are untagged. Let's untag the destination. Dst = hipe_icode:phi_dst(I), NewDst = hipe_icode:mk_new_fvar(), - NewMap1 = gb_trees:enter(Dst, NewDst, NewMap), + NewMap1 = NewMap#{Dst => NewDst}, NewI = subst_phi_uncond(I, NewDst, PhiMap), transform_instrs(Left, NewPhiMap, NewMap1, [NewI|Acc]); _ -> @@ -233,7 +289,7 @@ transform_instrs([I|Left], PhiMap, Map, Acc) -> [Src] -> case lookup(Src, Map) of none -> - NewMap1 = gb_trees:enter(Src, {assigned, Dst}, NewMap), + NewMap1 = NewMap#{Src => {assigned, Dst}}, transform_instrs(Left, NewPhiMap, NewMap1, [I|Acc]); Dst -> %% This is the instruction that untagged the variable. @@ -256,7 +312,7 @@ transform_instrs([I|Left], PhiMap, Map, Acc) -> unsafe_tag_float -> [Dst] = hipe_icode:defines(I), [Src] = hipe_icode:uses(I), - NewMap1 = gb_trees:enter(Dst, {assigned, Src}, NewMap), + NewMap1 = NewMap#{Dst => {assigned, Src}}, transform_instrs(Left, NewPhiMap, NewMap1,[I|Acc]); _ -> {NewMap1, NewAcc} = check_for_fop_candidates(I, NewMap, Acc), @@ -269,6 +325,9 @@ transform_instrs([I|Left], PhiMap, Map, Acc) -> transform_instrs([], _PhiMap, Map, Acc) -> {Map, lists:reverse(Acc)}. +-spec check_for_fop_candidates(icode_instr(), var_map(), icode_instrs()) + -> {var_map(), icode_instrs()}. + check_for_fop_candidates(I, Map, Acc) -> case is_fop_cand(I) of false -> @@ -311,6 +370,8 @@ check_for_fop_candidates(I, Map, Acc) -> end. +-spec handle_untagged_arguments(icode_instr(), var_map()) -> icode_instrs(). + %% If this is an instruction that needs to operate on tagged values, %% which currently are untagged, we must tag the values and perhaps %% end the fp ebb. @@ -322,23 +383,24 @@ handle_untagged_arguments(I, Map) -> Tag -> TagIntrs = [hipe_icode:mk_primop([Dst], unsafe_tag_float, - [gb_trees:get(Dst, Map)]) || Dst <- Tag], + [maps:get(Dst, Map)]) || Dst <- Tag], [I|TagIntrs] end. +-spec do_prelude(var_map_phi()) -> {[icode_phi()], var_map()}. + %% Add phi nodes for untagged fp values. -do_prelude(Map) -> - case gb_trees:lookup(phi, Map) of - none -> - {[], Map}; - {value, List} -> - %%io:format("Adding phi: ~w\n", [List]), - Fun = fun ({FVar, Bindings}, Acc) -> - [hipe_icode:mk_phi(FVar, Bindings)|Acc] - end, - {lists:foldl(Fun, [], List), gb_trees:delete(phi, Map)} - end. +do_prelude(Map = #{phi := List}) -> + %%io:format("Adding phi: ~w\n", [List]), + Fun = fun ({FVar, Bindings}, Acc) -> + [hipe_icode:mk_phi(FVar, Bindings)|Acc] + end, + {lists:foldl(Fun, [], List), maps:remove(phi, Map)}; +do_prelude(Map) -> {[], Map}. + +-spec split_code([I]) -> {[I], I} when + I :: icode_instr(). split_code(Code) -> split_code(Code, []). @@ -349,6 +411,8 @@ split_code([I|Left], Acc) -> split_code(Left, [I|Acc]). +-spec finalize(state()) -> state(). + %% When all code is mapped to fp instructions we must make sure that %% the fp ebb information going into each block is the same as the %% information coming out of each predecessor. Otherwise, we must add @@ -360,17 +424,25 @@ finalize(State) -> Edges = needs_fcheckerror(NewState), finalize(Edges, NewState). +-spec finalize([edge()], state()) -> state(). + finalize([{From, To}|Left], State) -> NewState = add_fp_ebb_fixup(From, To, State), finalize(Left, NewState); finalize([], State) -> State. +-spec needs_fcheckerror(state()) -> [{none | icode_lbl(), icode_lbl()}]. + needs_fcheckerror(State) -> Cfg = state__cfg(State), Labels = hipe_icode_cfg:labels(Cfg), needs_fcheckerror(Labels, State, []). +-spec needs_fcheckerror([icode_lbl()], state(), + [{none | icode_lbl(), icode_lbl()}]) + -> [{none | icode_lbl(), icode_lbl()}]. + needs_fcheckerror([Label|Left], State, Acc) -> case state__get_in_block_in(State, Label) of {true, _} -> @@ -395,6 +467,8 @@ needs_fcheckerror([Label|Left], State, Acc) -> needs_fcheckerror([], _State, Acc) -> Acc. +-spec add_fp_ebb_fixup(none | icode_lbl(), icode_lbl(), state()) -> state(). + add_fp_ebb_fixup('none', To, State) -> %% Add the fcheckerror to the start of the block. BB = state__bb(State, To), @@ -416,9 +490,15 @@ add_fp_ebb_fixup(From, To, State) -> NewToBB = hipe_bb:code_update(ToBB, NewToCode), state__bb_add(NewState1, To, NewToBB). +-spec redirect_phis(icode_instrs(), icode_lbl(), icode_lbl()) + -> icode_instrs(). + redirect_phis(Code, OldFrom, NewFrom) -> redirect_phis(Code, OldFrom, NewFrom, []). +-spec redirect_phis(icode_instrs(), icode_lbl(), icode_lbl(), icode_instrs()) + -> icode_instrs(). + redirect_phis([I|Is] = Code, OldFrom, NewFrom, Acc) -> case I of #icode_phi{} -> @@ -430,13 +510,20 @@ redirect_phis([I|Is] = Code, OldFrom, NewFrom, Acc) -> redirect_phis([], _OldFrom, _NewFrom, Acc) -> lists:reverse(Acc). +-spec subst_phi(icode_phi(), icode_variable(), edge_map()) + -> icode_phi(). + subst_phi(I, Dst, Map) -> ArgList = subst_phi_uses0(hipe_icode:phi_arglist(I), Map, []), hipe_icode:mk_phi(Dst, ArgList). +-spec subst_phi_uses0([{icode_lbl(), icode_variable()}], edge_map(), + [{icode_lbl(), icode_variable()}]) + -> [{icode_lbl(), icode_variable()}]. + subst_phi_uses0([{Pred, Var}|Left], Map, Acc) -> - case gb_trees:lookup(Var, Map) of - {value, List} -> + case Map of + #{Var := List} -> case lists:keyfind(Pred, 1, List) of {Pred, {assigned, _NewVar}} -> %% The variable is untagged, but it has been assigned. Keep it! @@ -448,20 +535,27 @@ subst_phi_uses0([{Pred, Var}|Left], Map, Acc) -> %% The variable is not untagged. subst_phi_uses0(Left, Map, [{Pred, Var} | Acc]) end; - none -> + #{} -> %% The variable is not untagged. subst_phi_uses0(Left, Map, [{Pred, Var} | Acc]) end; subst_phi_uses0([], _Map, Acc) -> Acc. +-spec subst_phi_uncond(icode_phi(), icode_variable(), edge_map()) + -> icode_phi(). + subst_phi_uncond(I, Dst, Map) -> ArgList = subst_phi_uses_uncond0(hipe_icode:phi_arglist(I), Map, []), hipe_icode:mk_phi(Dst, ArgList). +-spec subst_phi_uses_uncond0([{icode_lbl(), icode_variable()}], edge_map(), + [{icode_lbl(), icode_variable()}]) + -> [{icode_lbl(), icode_variable()}]. + subst_phi_uses_uncond0([{Pred, Var}|Left], Map, Acc) -> - case gb_trees:lookup(Var, Map) of - {value, List} -> + case Map of + #{Var := List} -> case lists:keyfind(Pred, 1, List) of {Pred, {assigned, NewVar}} -> %% The variable is untagged! @@ -473,13 +567,15 @@ subst_phi_uses_uncond0([{Pred, Var}|Left], Map, Acc) -> %% The variable is not untagged. subst_phi_uses_uncond0(Left, Map, [{Pred, Var} | Acc]) end; - none -> + #{} -> %% The variable is not untagged. subst_phi_uses_uncond0(Left, Map, [{Pred, Var} | Acc]) end; subst_phi_uses_uncond0([], _Map, Acc) -> Acc. +-spec place_error_handling(worklist(), state()) -> state(). + place_error_handling(WorkList, State) -> case get_work(WorkList) of none -> @@ -502,6 +598,9 @@ place_error_handling(WorkList, State) -> end end. +-spec place_error(icode_instrs(), in_block(), icode_instrs()) + -> {icode_instrs(), in_block()}. + place_error([I|Left], InBlock, Acc) -> case I of #icode_call{} -> @@ -638,12 +737,10 @@ instr_allowed_in_fp_ebb(Instr) -> %%============================================================= %% ------------------------------------------------------------ -%% Handling the gb_tree +%% Handling the variable map -delete_all([Key|Left], Tree) -> - delete_all(Left, gb_trees:delete_any(Key, Tree)); -delete_all([], Tree) -> - Tree. +-spec lookup_list([icode_var() | icode_const()], var_map()) + -> [none | icode_fvar()]. lookup_list(List, Info) -> lookup_list(List, fun lookup/2, Info, []). @@ -653,33 +750,43 @@ lookup_list([H|T], Fun, Info, Acc) -> lookup_list([], _, _, Acc) -> lists:reverse(Acc). +-spec lookup(icode_var() | icode_const(), var_map()) -> none | icode_fvar(). + lookup(Key, Tree) -> case hipe_icode:is_const(Key) of %% This can be true if the same constant has been %% untagged more than once true -> none; false -> - case gb_trees:lookup(Key, Tree) of - none -> none; - {value, {assigned, Val}} -> Val; - {value, Val} -> Val + case Tree of + #{Key := {assigned, Val}} -> Val; + #{Key := Val} -> Val; + #{} -> none end end. +-spec lookup_list_keep_consts([icode_var() | icode_const()], var_map()) + -> [none | icode_fvar() | icode_const()]. + lookup_list_keep_consts(List, Info) -> lookup_list(List, fun lookup_keep_consts/2, Info, []). +-spec lookup_keep_consts(icode_var() | icode_const(), var_map()) + -> none | icode_fvar() | icode_const(). + lookup_keep_consts(Key, Tree) -> case hipe_icode:is_const(Key) of true -> Key; false -> - case gb_trees:lookup(Key, Tree) of - none -> none; - {value, {assigned, Val}} -> Val; - {value, Val} -> Val + case Tree of + #{Key := {assigned, Val}} -> Val; + #{Key := Val} -> Val; + #{} -> none end end. +-spec get_type(icode_argument()) -> erl_types:erl_type(). + get_type(Var) -> case hipe_icode:is_const(Var) of true -> erl_types:t_from_term(hipe_icode:const_value(Var)); @@ -695,98 +802,108 @@ get_type(Var) -> %% ------------------------------------------------------------ %% Handling the map from variables to fp-variables +-spec join_maps([edge()], edge_map()) -> initial_var_map(). + join_maps(Edges, EdgeMap) -> - join_maps(Edges, EdgeMap, gb_trees:empty()). + join_maps(Edges, EdgeMap, #{}). join_maps([Edge = {Pred, _}|Left], EdgeMap, Map) -> - case gb_trees:lookup(Edge, EdgeMap) of - none -> + case EdgeMap of + #{Edge := OldMap} -> + NewMap = join_maps0(maps:to_list(OldMap), Pred, Map), + join_maps(Left, EdgeMap, NewMap); + #{} -> %% All predecessors have not been handled. Use empty map. - gb_trees:empty(); - {value, OldMap} -> - NewMap = join_maps0(gb_trees:to_list(OldMap), Pred, Map), - join_maps(Left, EdgeMap, NewMap) + #{} end; join_maps([], _, Map) -> Map. -join_maps0([{phi, _}|Tail], Pred, Map) -> - join_maps0(Tail, Pred, Map); -join_maps0([{Var, FVar}|Tail], Pred, Map) -> - case gb_trees:lookup(Var, Map) of - none -> - join_maps0(Tail, Pred, gb_trees:enter(Var, [{Pred, FVar}], Map)); - {value, List} -> +-spec join_maps0(list(), icode_lbl(), initial_var_map()) -> initial_var_map(). + +join_maps0([{Var=#icode_variable{kind=var}, FVar}|Tail], Pred, Map) -> + case Map of + #{Var := List} -> case lists:keyfind(Pred, 1, List) of false -> - join_maps0(Tail, Pred, gb_trees:update(Var, [{Pred, FVar}|List], Map)); + join_maps0(Tail, Pred, Map#{Var := [{Pred, FVar}|List]}); {Pred, FVar} -> %% No problem. join_maps0(Tail, Pred, Map); _ -> exit('New binding to same variable') - end + end; + #{} -> + join_maps0(Tail, Pred, Map#{Var => [{Pred, FVar}]}) end; join_maps0([], _, Map) -> Map. +-spec filter_map(initial_var_map(), pos_integer()) -> var_map_phi(). + filter_map(Map, NofPreds) -> - filter_map(gb_trees:to_list(Map), NofPreds, Map). + filter_map(maps:to_list(Map), NofPreds, Map). + +-spec filter_map([{icode_var(), incoming_fvars()}], pos_integer(), + var_map_phi()) -> var_map_phi(). filter_map([{Var, Bindings}|Left], NofPreds, Map) -> case length(Bindings) =:= NofPreds of true -> + BindingsAllAssigned = lists:all(fun({_, {assigned, _}}) -> true; + ({_, _}) -> false + end, Bindings), case all_args_equal(Bindings) of true -> - {_, FVar} = hd(Bindings), - filter_map(Left, NofPreds, gb_trees:update(Var, FVar, Map)); + NewBinding = + case hd(Bindings) of + {Pred, {assigned, FVar0}} when is_integer(Pred) -> + case BindingsAllAssigned of + true -> {assigned, FVar0}; + false -> FVar0 + end; + {Pred, FVar0} when is_integer(Pred) -> FVar0 + end, + filter_map(Left, NofPreds, Map#{Var := NewBinding}); false -> PhiDst = hipe_icode:mk_new_fvar(), PhiArgs = strip_of_assigned(Bindings), NewMap = - case gb_trees:lookup(phi, Map) of - none -> - gb_trees:insert(phi, [{PhiDst, PhiArgs}], Map); - {value, Val} -> - gb_trees:update(phi, [{PhiDst, PhiArgs}|Val], Map) + case Map of + #{phi := Val} -> + Map#{phi := [{PhiDst, PhiArgs}|Val]}; + #{} -> + Map#{phi => [{PhiDst, PhiArgs}]} end, NewBinding = - case bindings_are_assigned(Bindings) of + case BindingsAllAssigned of true -> {assigned, PhiDst}; false -> PhiDst end, - filter_map(Left, NofPreds, gb_trees:update(Var, NewBinding, NewMap)) + filter_map(Left, NofPreds, NewMap#{Var := NewBinding}) end; false -> - filter_map(Left, NofPreds, gb_trees:delete(Var, Map)) + filter_map(Left, NofPreds, maps:remove(Var, Map)) end; filter_map([], _NofPreds, Map) -> Map. -bindings_are_assigned([{_, {assigned, _}}|Left]) -> - assert_assigned(Left), - true; -bindings_are_assigned(Bindings) -> - assert_not_assigned(Bindings), - false. - -assert_assigned([{_, {assigned, _}}|Left]) -> - assert_assigned(Left); -assert_assigned([]) -> - ok. - -assert_not_assigned([{_, FVar}|Left]) -> - true = hipe_icode:is_fvar(FVar), - assert_not_assigned(Left); -assert_not_assigned([]) -> - ok. +-spec all_args_equal(incoming_fvars()) -> boolean(). %% all_args_equal returns true if the mapping for a variable is the %% same from all predecessors, i.e., we do not need a phi-node. +%% During the fixpoint loop, a mapping might become assigned, without that +%% information having propagated into all predecessors. We take care to answer +%% true even if FVar is only assigned in some predecessors. + +all_args_equal([{_, {assigned, FVar}}|Left]) -> + all_args_equal(Left, FVar); all_args_equal([{_, FVar}|Left]) -> all_args_equal(Left, FVar). +all_args_equal([{_, {assigned, FVar1}}|Left], FVar1) -> + all_args_equal(Left, FVar1); all_args_equal([{_, FVar1}|Left], FVar1) -> all_args_equal(Left, FVar1); all_args_equal([], _) -> @@ -795,20 +912,24 @@ all_args_equal(_, _) -> false. +-spec add_new_bindings_unassigned([icode_var()], var_map()) -> var_map(). + %% We differentiate between values that have been assigned as %% tagged variables and those that got a 'virtual' binding. add_new_bindings_unassigned([Var|Left], Map) -> FVar = hipe_icode:mk_new_fvar(), - add_new_bindings_unassigned(Left, gb_trees:insert(Var, FVar, Map)); + add_new_bindings_unassigned(Left, Map#{Var => FVar}); add_new_bindings_unassigned([], Map) -> Map. +-spec add_new_bindings_assigned([icode_var()], var_map()) -> var_map(). + add_new_bindings_assigned([Var|Left], Map) -> case lookup(Var, Map) of none -> FVar = hipe_icode:mk_new_fvar(), - NewMap = gb_trees:insert(Var, {assigned, FVar}, Map), + NewMap = Map#{Var => {assigned, FVar}}, add_new_bindings_assigned(Left, NewMap); _ -> add_new_bindings_assigned(Left, Map) @@ -816,6 +937,8 @@ add_new_bindings_assigned([Var|Left], Map) -> add_new_bindings_assigned([], Map) -> Map. +-spec strip_of_assigned(incoming_fvars()) -> [{icode_lbl(), icode_fvar()}]. + strip_of_assigned(List) -> strip_of_assigned(List, []). @@ -830,6 +953,8 @@ strip_of_assigned([], Acc) -> %% Help functions for the transformation from ordinary instruction to %% fp-instruction +-spec is_fop_cand(icode_instr()) -> boolean(). + is_fop_cand(I) -> case hipe_icode:call_fun(I) of '/' -> true; @@ -840,6 +965,8 @@ is_fop_cand(I) -> end end. +-spec any_is_float([icode_argument()]) -> boolean(). + any_is_float(Vars) -> lists:any(fun (V) -> erl_types:t_is_float(get_type(V)) end, Vars). @@ -866,25 +993,32 @@ fun_to_fop(Fun) -> end. +-spec must_be_tagged(icode_var(), var_map()) -> boolean(). + %% If there is a tagged version of this variable available we don't %% have to tag the untagged version. must_be_tagged(Var, Map) -> - case gb_trees:lookup(Var, Map) of - none -> false; - {value, {assigned, _}} -> false; - {value, Val} -> hipe_icode:is_fvar(Val) + case Map of + #{Var := {assigned, _}} -> false; + #{Var := Val} -> hipe_icode:is_fvar(Val); + #{} -> false end. +-spec get_conv_instrs([icode_argument()], var_map()) -> icode_instrs(). + %% Converting to floating point variables get_conv_instrs(Vars, Map) -> get_conv_instrs(Vars, Map, []). +-spec get_conv_instrs([icode_argument()], var_map(), icode_instrs()) + -> icode_instrs(). + get_conv_instrs([Var|Left], Map, Acc) -> - {_, Dst} = gb_trees:get(Var, Map), - NewI = + #{Var := {_, Dst}} = Map, + NewI = case erl_types:t_is_float(get_type(Var)) of true -> [hipe_icode:mk_primop([Dst], unsafe_untag_float, [Var])]; @@ -896,6 +1030,8 @@ get_conv_instrs([], _, Acc) -> Acc. +-spec conv_consts([icode_const()], icode_instr()) -> icode_instr(). + conv_consts(ConstArgs, I) -> conv_consts(ConstArgs, I, []). @@ -934,63 +1070,79 @@ state__bb_add(S = #state{cfg = Cfg}, Label, BB) -> NewCfg = hipe_icode_cfg:bb_add(Cfg, Label, BB), S#state{cfg = NewCfg}. +-spec state__map(state(), icode_lbl()) -> initial_var_map(). + state__map(S = #state{edge_map = EM}, To) -> join_maps([{From, To} || From <- state__pred(S, To)], EM). +-spec state__map_update(state(), icode_lbl(), icode_lbl(), var_map()) -> + fixpoint | state(). + state__map_update(S = #state{edge_map = EM}, From, To, Map) -> FromTo = {From, To}, MapChanged = - case gb_trees:lookup(FromTo, EM) of - {value, Map1} -> not match(Map1, Map); - none -> true + case EM of + #{FromTo := Map1} -> not match(Map1, Map); + #{} -> true end, case MapChanged of true -> - NewEM = gb_trees:enter(FromTo, Map, EM), + NewEM = EM#{FromTo => Map}, S#state{edge_map = NewEM}; false -> fixpoint end. +-spec state__join_in_block(state(), icode_lbl()) + -> fixpoint | {state(), in_block()}. + state__join_in_block(S = #state{fp_ebb_map = Map}, Label) -> Pred = state__pred(S, Label), Edges = [{X, Label} || X <- Pred], - NewInBlock = join_in_block([gb_trees:lookup(X, Map) || X <- Edges]), + NewInBlock = join_in_block([maps:find(X, Map) || X <- Edges]), InBlockLabel = {inblock_in, Label}, - case gb_trees:lookup(InBlockLabel, Map) of - none -> - NewMap = gb_trees:insert(InBlockLabel, NewInBlock, Map), - {S#state{fp_ebb_map = NewMap}, NewInBlock}; - {value, NewInBlock} -> + case Map of + #{InBlockLabel := NewInBlock} -> fixpoint; - _Other -> - NewMap = gb_trees:update(InBlockLabel, NewInBlock, Map), + _ -> + NewMap = Map#{InBlockLabel => NewInBlock}, {S#state{fp_ebb_map = NewMap}, NewInBlock} end. +-spec state__in_block_out_update(state(), icode_lbl(), in_block()) + -> state(). + state__in_block_out_update(S = #state{fp_ebb_map = Map}, Label, NewInBlock) -> Succ = state__succ(S, Label), Edges = [{Label, X} || X <- Succ], NewMap = update_edges(Edges, NewInBlock, Map), - NewMap1 = gb_trees:enter({inblock_out, Label}, NewInBlock, NewMap), + NewMap1 = NewMap#{{inblock_out, Label} => NewInBlock}, S#state{fp_ebb_map = NewMap1}. +-spec update_edges([edge()], in_block(), fp_ebb_map()) -> fp_ebb_map(). + update_edges([Edge|Left], NewInBlock, Map) -> - NewMap = gb_trees:enter(Edge, NewInBlock, Map), + NewMap = Map#{Edge => NewInBlock}, update_edges(Left, NewInBlock, NewMap); update_edges([], _NewInBlock, NewMap) -> NewMap. +-spec join_in_block([error | {ok, in_block()}]) -> in_block(). + join_in_block([]) -> false; -join_in_block([none|_]) -> +join_in_block([error|_]) -> false; -join_in_block([{value, InBlock}|Left]) -> +join_in_block([{ok, InBlock}|Left]) -> join_in_block(Left, InBlock). -join_in_block([none|_], _Current) -> +-spec join_in_block([error | {ok, in_block()}], Current) + -> false | Current when + Current :: in_block(). + +join_in_block([error|_], _Current) -> false; -join_in_block([{value, InBlock}|Left], Current) -> +join_in_block([{ok, InBlock}|Left], Current) -> if Current =:= InBlock -> join_in_block(Left, Current); Current =:= false -> false; InBlock =:= false -> false; @@ -998,19 +1150,25 @@ join_in_block([{value, InBlock}|Left], Current) -> end; join_in_block([], Current) -> Current. - + + +-spec state__get_in_block_in(state(), icode_lbl()) -> in_block(). state__get_in_block_in(#state{fp_ebb_map = Map}, Label) -> - gb_trees:get({inblock_in, Label}, Map). + maps:get({inblock_in, Label}, Map). state__get_in_block_out(#state{fp_ebb_map = Map}, Label) -> - gb_trees:get({inblock_out, Label}, Map). + maps:get({inblock_out, Label}, Map). + +-spec new_worklist(state()) -> worklist(). new_worklist(#state{cfg = Cfg}) -> Start = hipe_icode_cfg:start_label(Cfg), {[Start], [], gb_sets:insert(Start, gb_sets:empty())}. +-spec get_work(worklist()) -> none | {icode_lbl(), worklist()}. + get_work({[Label|Left], List, Set}) -> {Label, {Left, List, gb_sets:delete(Label, Set)}}; get_work({[], [], _Set}) -> @@ -1018,6 +1176,8 @@ get_work({[], [], _Set}) -> get_work({[], List, Set}) -> get_work({lists:reverse(List), [], Set}). +-spec add_work(worklist(), [icode_lbl()]) -> worklist(). + add_work({List1, List2, Set} = Work, [Label|Left]) -> case gb_sets:is_member(Label, Set) of true -> @@ -1030,15 +1190,7 @@ add_work({List1, List2, Set} = Work, [Label|Left]) -> add_work(WorkList, []) -> WorkList. -match(Tree1, Tree2) -> - match_1(gb_trees:to_list(Tree1), Tree2) andalso - match_1(gb_trees:to_list(Tree2), Tree1). +-spec match(var_map(), var_map()) -> boolean(). -match_1([{Key, Val}|Left], Tree2) -> - case gb_trees:lookup(Key, Tree2) of - {value, Val} -> - match_1(Left, Tree2); - _ -> false - end; -match_1([], _) -> - true. +match(Tree1, Tree2) when is_map(Tree1), is_map(Tree2) -> + Tree1 =:= Tree2. diff --git a/lib/hipe/test/basic_SUITE_data/basic_floats.erl b/lib/hipe/test/basic_SUITE_data/basic_floats.erl index eec175075a..ce28f6e156 100644 --- a/lib/hipe/test/basic_SUITE_data/basic_floats.erl +++ b/lib/hipe/test/basic_SUITE_data/basic_floats.erl @@ -18,6 +18,8 @@ test() -> ok = test_catch_fp_conv(), ok = test_fp_with_fp_exceptions(), %% ok = test_fmt_double_fpe_leak(), % this requires printing + ok = test_icode_type_crash(), + ok = test_icode_type_crash_2(), ok. %%-------------------------------------------------------------------- @@ -178,3 +180,71 @@ test_fmt_double_fpe_leak(X, Y) -> math:log10(Y). int_two() -> 2. + +%%-------------------------------------------------------------------- +%% Contains code which confuses the icode_type analysis and results +%% in a compiler crash. Stipped down from code sent by Paul Guyot. +%% Compiles alright with the option 'no_icode_type' but that defeats +%% the purpose of the test. + +test_icode_type_crash() -> + Fun = f(1, 2, 3), + 42.0 = Fun(), + ok. + +f(A, B, C) -> + fun () -> + X = case A of + 0 -> 1 / B; + _ -> A / C + end, + Y = case B of + a -> 1.0; + b -> 2.0; + _ -> 6.0 + end, + Z = case C of + c -> 0.1 * X; + _ -> 7.0 + end, + Y * Z + end. + +%%-------------------------------------------------------------------- +%% Contains another case that crashed hipe_icode_fp. This sample was +%% sent by Mattias Jansson (25 Nov 2015). It compiled alright with the +%% option 'no_icode_type' but that defeats the purpose of the test. +%% Unfortunately, the execution of this code goes into an infinite +%% loop, even if the map in the second argument of eat_what/2 gets the +%% appropriate key-value pairs. Still, it is retained as a test +%% because it exposed a different crash than test_icode_type_crash/0. + +test_icode_type_crash_2() -> + {'EXIT', {function_clause, _}} = (catch eat()), + ok. + +eat() -> + eat_what(1.0, #{}). + +eat_what(Factor, #{rat_type := LT} = Rat) -> + #{cheese := Cheese} = Rat, + UnitCheese = Cheese / 2, + RetA = case eat() of + {full, RetA1} -> + CheeseB2 = min(RetA1, UnitCheese) * Factor, + case eat() of + full -> {win, RetA1}; + hungry -> {partial, RetA1 - CheeseB2} + end; + AOther -> AOther + end, + RetB = case eat() of + {full, RetB1} -> + CheeseA2 = min(RetB1, UnitCheese) * Factor, + rat:init(single, LT, CheeseA2), + case eat() of + full -> {full, RetB1}; + hungry -> {hungry, RetB1 - CheeseA2} + end + end, + {RetA, RetB}. diff --git a/lib/kernel/src/file.erl b/lib/kernel/src/file.erl index 1007f04413..1076e02422 100644 --- a/lib/kernel/src/file.erl +++ b/lib/kernel/src/file.erl @@ -1227,7 +1227,8 @@ change_time(Name, {{AY, AM, AD}, {AH, AMin, ASec}}=Atime, %% Send data using sendfile %% --define(MAX_CHUNK_SIZE, (1 bsl 20)*20). %% 20 MB, has to fit in primary memory +%% 1 MB, Windows seems to behave badly if it is much larger then this +-define(MAX_CHUNK_SIZE, (1 bsl 20)). -spec sendfile(RawFile, Socket, Offset, Bytes, Opts) -> {'ok', non_neg_integer()} | {'error', inet:posix() | diff --git a/lib/sasl/src/systools_make.erl b/lib/sasl/src/systools_make.erl index d207dc15bb..154374cd8c 100644 --- a/lib/sasl/src/systools_make.erl +++ b/lib/sasl/src/systools_make.erl @@ -1453,16 +1453,37 @@ behave([H|T]) -> behave([]) -> []. -%%______________________________________________________________________ -%% mandatory modules; this modules must be loaded before processes -%% can be started. These are a collection of modules from the kernel -%% and stdlib applications. -%% Nowadays, error_handler dynamically loads almost every module. -%% The error_handler self must still be there though. - mandatory_modules() -> - %% Sorted - [error_handler]. + [error_handler, %Truly mandatory. + + %% Modules that are almost always needed. Listing them here + %% helps the init module to load them faster. Modules not + %% listed here will be loaded by the error_handler module. + %% + %% Keep this list sorted. + application, + application_controller, + application_master, + code, + code_server, + erl_eval, + erl_lint, + erl_parse, + error_logger, + ets, + file, + filename, + file_server, + file_io_server, + gen, + gen_event, + gen_server, + heart, + kernel, + lists, + proc_lib, + supervisor + ]. %%______________________________________________________________________ %% This is the modules that are preloaded into the Erlang system. diff --git a/lib/sasl/test/test_lib.hrl b/lib/sasl/test/test_lib.hrl index b16c4ac34c..2d897e9903 100644 --- a/lib/sasl/test/test_lib.hrl +++ b/lib/sasl/test/test_lib.hrl @@ -1,3 +1,3 @@ -define(ertsvsn,"4.4"). --define(kernelvsn,"3.0"). --define(stdlibvsn,"2.0"). +-define(kernelvsn,"4.0"). +-define(stdlibvsn,"2.5"). diff --git a/lib/ssh/src/ssh_info.erl b/lib/ssh/src/ssh_info.erl index 4e6e25bc70..2dfc55cd92 100644 --- a/lib/ssh/src/ssh_info.erl +++ b/lib/ssh/src/ssh_info.erl @@ -25,7 +25,11 @@ -module(ssh_info). --compile(export_all). +-export([print/0, + print/1, + string/0, + collect_pids/0 + ]). print() -> print(user). @@ -34,55 +38,54 @@ print(D) -> try supervisor:which_children(ssh_sup) of _ -> - io:nl(D), + io__nl(D), print_general(D), - io:nl(D), + io__nl(D), underline(D, "Client part", $=), print_clients(D), - io:nl(D), + io__nl(D), underline(D, "Server part", $=), print_servers(D), - io:nl(D), - %% case os:type() of - %% {unix,_} -> - %% io:nl(), - %% underline("Linux part", $=), - %% underline("Listening"), - %% catch io:format(os:cmd("netstat -tpln")), - %% io:nl(), - %% underline("Other"), - %% catch io:format(os:cmd("netstat -tpn")); - %% _ -> ok - %% end, + io__nl(D), underline(D, "Supervisors", $=), walk_sups(D, ssh_sup), - io:nl(D) + io__nl(D) catch _:_ -> - io:format(D,"Ssh not found~n",[]) + io__format(D,"Ssh not found~n",[]) + end. + +string() -> + Pid = spawn(fun init/0), + print(Pid), + Pid ! {get,self()}, + receive + {result,R} -> R end. %%%================================================================ print_general(D) -> {_Name, Slogan, Ver} = lists:keyfind(ssh,1,application:which_applications()), underline(D, io_lib:format("~s ~s", [Slogan, Ver]), $=), - io:format(D, 'This printout is generated ~s. ~n',[datetime()]). + io__format(D, 'This printout is generated ~s. ~n',[datetime()]). %%%================================================================ +-define(INDENT, " "). + print_clients(D) -> PrintClient = fun(X) -> print_client(D,X) end, try lists:foreach(PrintClient, supervisor:which_children(sshc_sup)) catch C:E -> - io:format(D, '***FAILED: ~p:~p~n',[C,E]) + io__format(D, '***FAILED: ~p:~p~n',[C,E]) end. print_client(D, {undefined,Pid,supervisor,[ssh_connection_handler]}) -> {{Local,Remote},_Str} = ssh_connection_handler:get_print_info(Pid), - io:format(D, " Local=~s Remote=~s ConnectionRef=~p~n",[fmt_host_port(Local),fmt_host_port(Remote),Pid]); + io__format(D, ?INDENT"Local: ~s Remote: ~s ConnectionRef = ~p~n",[fmt_host_port(Local),fmt_host_port(Remote),Pid]); print_client(D, Other) -> - io:format(D, " [[Other 1: ~p]]~n",[Other]). + io__format(D, " [[Other 1: ~p]]~n",[Other]). %%%================================================================ @@ -92,51 +95,56 @@ print_servers(D) -> lists:foreach(PrintServer, supervisor:which_children(sshd_sup)) catch C:E -> - io:format(D, '***FAILED: ~p:~p~n',[C,E]) + io__format(D, '***FAILED: ~p:~p~n',[C,E]) end. -print_server(D, {{server,ssh_system_sup,LocalHost,LocalPort},Pid,supervisor,[ssh_system_sup]}) when is_pid(Pid) -> - io:format(D, 'Local=~s (~p children)~n',[fmt_host_port({LocalHost,LocalPort}), - ssh_acceptor:number_of_connections(Pid)]), + +print_server(D, {{server,ssh_system_sup,LocalHost,LocalPort,Profile},Pid,supervisor,[ssh_system_sup]}) when is_pid(Pid) -> + io__format(D, ?INDENT"Listen: ~s (~p children) Profile ~p~n",[fmt_host_port({LocalHost,LocalPort}), + ssh_acceptor:number_of_connections(Pid), + Profile]), PrintSystemSup = fun(X) -> print_system_sup(D,X) end, - lists:foreach(PrintSystemSup, supervisor:which_children(Pid)); -print_server(D, Other) -> - io:format(D, " [[Other 2: ~p]]~n",[Other]). - + lists:foreach(PrintSystemSup, supervisor:which_children(Pid)). + + print_system_sup(D, {Ref,Pid,supervisor,[ssh_subsystem_sup]}) when is_reference(Ref), - is_pid(Pid) -> + is_pid(Pid) -> PrintChannels = fun(X) -> print_channels(D,X) end, lists:foreach(PrintChannels, supervisor:which_children(Pid)); -print_system_sup(D, {{ssh_acceptor_sup,LocalHost,LocalPort}, Pid,supervisor, [ssh_acceptor_sup]}) when is_pid(Pid) -> - io:format(D, " [Acceptor for ~s]~n",[fmt_host_port({LocalHost,LocalPort})]); -print_system_sup(D, Other) -> - io:format(D, " [[Other 3: ~p]]~n",[Other]). +print_system_sup(D, {{ssh_acceptor_sup,_LocalHost,_LocalPort,_Profile}, Pid, supervisor, [ssh_acceptor_sup]}) when is_pid(Pid) -> + io__format(D, ?INDENT?INDENT"[Acceptor Pid ~p]~n",[Pid]). -print_channels(D, {{server,ssh_channel_sup,_,_},Pid,supervisor,[ssh_channel_sup]}) when is_pid(Pid) -> - PrintChannel = fun(X) -> print_channel(D,X) end, - lists:foreach(PrintChannel, supervisor:which_children(Pid)); -print_channels(D, Other) -> - io:format(D, " [[Other 4: ~p]]~n",[Other]). +print_channels(D, {{server,ssh_channel_sup,_,_},Pid,supervisor,[ssh_channel_sup]}) when is_pid(Pid) -> + Children = supervisor:which_children(Pid), + ChannelPids = [P || {R,P,worker,[ssh_channel]} <- Children, + is_pid(P), + is_reference(R)], + case ChannelPids of + [] -> io__format(D, ?INDENT?INDENT"No channels~n",[]); + [Ch1Pid|_] -> + {{ConnManager,_}, _Str} = ssh_channel:get_print_info(Ch1Pid), + {{_,Remote},_} = ssh_connection_handler:get_print_info(ConnManager), + io__format(D, ?INDENT?INDENT"Remote: ~s ConnectionRef = ~p~n",[fmt_host_port(Remote),ConnManager]), + lists:foreach(fun(P) -> print_ch(D,P) end, ChannelPids) + end; +print_channels(_D, {{server,ssh_connection_sup,_,_},Pid,supervisor,[ssh_connection_sup]}) when is_pid(Pid) -> + ok. % The supervisor of the connections socket owning process -print_channel(D, {Ref,Pid,worker,[ssh_channel]}) when is_reference(Ref), - is_pid(Pid) -> +print_ch(D, Pid) -> {{ConnManager,ChannelID}, Str} = ssh_channel:get_print_info(Pid), - {{Local,Remote},StrM} = ssh_connection_handler:get_print_info(ConnManager), - io:format(D, ' ch ~p: ~s ~s',[ChannelID, StrM, Str]), - io:format(D, " Local=~s Remote=~s~n",[fmt_host_port(Local),fmt_host_port(Remote)]); -print_channel(D, Other) -> - io:format(D, " [[Other 5: ~p]]~n",[Other]). - + {_LocalRemote,StrM} = ssh_connection_handler:get_print_info(ConnManager), + io__format(D, ?INDENT?INDENT?INDENT"ch ~p: ~s ~s~n",[ChannelID, StrM, Str]). + %%%================================================================ -define(inc(N), (N+4)). walk_sups(D, StartPid) -> - io:format(D, "Start at ~p, ~s.~n",[StartPid,dead_or_alive(StartPid)]), + io__format(D, "Start at ~p, ~s.~n",[StartPid,dead_or_alive(StartPid)]), walk_sups(D, children(StartPid), _Indent=?inc(0)). walk_sups(D, [H={_,Pid,_,_}|T], Indent) -> - indent(D, Indent), io:format(D, '~200p ~p is ~s~n',[H,Pid,dead_or_alive(Pid)]), + indent(D, Indent), io__format(D, '~200p ~p is ~s~n',[H,Pid,dead_or_alive(Pid)]), case H of {_,_,supervisor,[ssh_connection_handler]} -> ok; {_,Pid,supervisor,_} -> walk_sups(D, children(Pid), ?inc(Indent)); @@ -159,7 +167,7 @@ dead_or_alive(Pid) when is_pid(Pid) -> _ -> "alive" end. -indent(D, I) -> io:format(D,'~*c',[I,$ ]). +indent(D, I) -> io__format(D,'~*c',[I,$ ]). children(Pid) -> Parent = self(), @@ -176,16 +184,13 @@ children(Pid) -> end. %%%================================================================ -underline(D, Str) -> - underline(D, Str, $-). - underline(D, Str, LineChar) -> Len = lists:flatlength(Str), - io:format(D, '~s~n',[Str]), + io__format(D, '~s~n',[Str]), line(D,Len,LineChar). line(D, Len, Char) -> - io:format(D, '~*c~n', [Len,Char]). + io__format(D, '~*c~n', [Len,Char]). datetime() -> @@ -196,8 +201,78 @@ datetime() -> fmt_host_port({{A,B,C,D},Port}) -> io_lib:format('~p.~p.~p.~p:~p',[A,B,C,D,Port]); fmt_host_port({Host,Port}) -> io_lib:format('~s:~p',[Host,Port]). +%%%################################################################ + +io__nl(D) when is_atom(D) -> io:nl(D); +io__nl(P) when is_pid(P) -> P ! {string,io_lib:nl()}. + +io__format(D, Fmt, Args) when is_atom(D) -> io:format(D, Fmt, Args); +io__format(P, Fmt, Args) when is_pid(P) -> P ! {string,io_lib:format(Fmt, Args)}. + + +init() -> loop([]). +loop(Acc) -> + receive + {string,Str} -> + loop([Str|Acc]); + {get,Who} -> + Who ! {result,lists:flatten(lists:reverse(Acc))} + end. + +%%%################################################################ +collect_pids() -> collect_pids(ssh_sup). + +collect_pids(P) -> + Collector = pcollect_pids(P, spawn(fun init_collector/0)), + Collector ! {get_values,self()}, + receive + {values,Values} -> + Values + end. + +%%%---------------- +pcollect_pids(undefined, Collector) -> + Collector; + +pcollect_pids(A, Collector) when is_atom(A) -> + pcollect_pids(whereis(A), Collector); + +pcollect_pids(Pid, Collector) when is_pid(Pid) -> + Collector ! {expect,Pid}, + spawn(fun() -> + lists:foreach( + fun(P2) -> + pcollect_pids(P2,Collector) + end, children(Pid)), + Collector ! {value,Pid,Pid} + end), + Collector; + +pcollect_pids({_,Pid,supervisor,_}, Collector) when is_pid(Pid) -> + pcollect_pids(Pid, Collector); + +pcollect_pids({_,Pid,worker,_}, Collector) when is_pid(Pid) -> + Collector ! {value,Pid,Pid}, + Collector; + +pcollect_pids(_, Collector) -> + Collector. + +%%%---------------- +init_collector() -> + loop_collector([],[]). + +loop_collector(Expects, Values) -> + receive + {expect, Ref} -> + loop_collector([Ref|Expects], Values); + {value, Ref, Val} -> + loop_collector(Expects--[Ref], [Val|Values]); + {get_values, From} when Expects==[] -> +%% Values=/=[] -> + From ! {values,Values} + end. + + -nyi(D) -> - io:format(D,'Not yet implemented~n',[]), - nyi. diff --git a/lib/ssh/test/ssh_algorithms_SUITE.erl b/lib/ssh/test/ssh_algorithms_SUITE.erl index 49ed15698c..2dc228a3cf 100644 --- a/lib/ssh/test/ssh_algorithms_SUITE.erl +++ b/lib/ssh/test/ssh_algorithms_SUITE.erl @@ -28,7 +28,7 @@ %% Note: This directive should only be used in test suites. -compile(export_all). --define(TIMEOUT, 50000). +-define(TIMEOUT, 10000). %%-------------------------------------------------------------------- %% Common Test interface functions ----------------------------------- @@ -36,7 +36,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}, - {timetrap,{minutes,10}}]. + {timetrap,{seconds,40}}]. all() -> %% [{group,kex},{group,cipher}... etc @@ -191,6 +191,9 @@ simple_exec_groups_no_match_too_large(Config) -> %%-------------------------------------------------------------------- %% Testing all default groups + +simple_exec_groups() -> [{timetrap,{seconds,180}}]. + simple_exec_groups(Config) -> Sizes = interpolate( public_key:dh_gex_group_sizes() ), lists:foreach( @@ -217,6 +220,7 @@ interpolate(Is) -> %%-------------------------------------------------------------------- %% Use the ssh client of the OS to connect + sshc_simple_exec(Config) -> PrivDir = ?config(priv_dir, Config), KnownHosts = filename:join(PrivDir, "known_hosts"), @@ -227,12 +231,21 @@ sshc_simple_exec(Config) -> ct:log("~p",[Cmd]), SshPort = open_port({spawn, Cmd}, [binary]), Expect = <<"2\n">>, + rcv_expected(SshPort, Expect). + + +rcv_expected(SshPort, Expect) -> receive {SshPort, {data,Expect}} -> ct:log("Got expected ~p from ~p",[Expect,SshPort]), catch port_close(SshPort), - ok + ok; + Other -> + ct:log("Got UNEXPECTED ~p",[Other]), + rcv_expected(SshPort, Expect) + after ?TIMEOUT -> + catch port_close(SshPort), ct:fail("Did not receive answer") end. diff --git a/lib/ssh/test/ssh_basic_SUITE.erl b/lib/ssh/test/ssh_basic_SUITE.erl index 094d28e879..18a05c0fb8 100644 --- a/lib/ssh/test/ssh_basic_SUITE.erl +++ b/lib/ssh/test/ssh_basic_SUITE.erl @@ -79,7 +79,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}, - {timetrap,{minutes,10}}]. + {timetrap,{seconds,40}}]. all() -> [app_test, diff --git a/lib/ssh/test/ssh_connection_SUITE.erl b/lib/ssh/test/ssh_connection_SUITE.erl index 6e90faf0e8..a1fbe28a83 100644 --- a/lib/ssh/test/ssh_connection_SUITE.erl +++ b/lib/ssh/test/ssh_connection_SUITE.erl @@ -37,7 +37,7 @@ %% [{ct_hooks,[ts_install_cth]}]. suite() -> - [{timetrap,{minutes,2}}]. + [{timetrap,{seconds,40}}]. all() -> [ @@ -314,11 +314,7 @@ ptty_alloc_pixel(Config) when is_list(Config) -> ssh:close(ConnectionRef). %%-------------------------------------------------------------------- - -interrupted_send() -> - [{doc, "Use a subsystem that echos n char and then sends eof to cause a channel exit partway through a large send."}]. - -interrupted_send(Config) when is_list(Config) -> +interrupted_send(Config) -> PrivDir = ?config(priv_dir, Config), UserDir = filename:join(PrivDir, nopubkey), % to make sure we don't use public-key-auth file:make_dir(UserDir), diff --git a/lib/ssh/test/ssh_echo_server.erl b/lib/ssh/test/ssh_echo_server.erl index 96c9aad135..8b6273c3fe 100644 --- a/lib/ssh/test/ssh_echo_server.erl +++ b/lib/ssh/test/ssh_echo_server.erl @@ -31,6 +31,7 @@ -export([init/1, handle_msg/2, handle_ssh_msg/2, terminate/2]). init([N]) -> + ct:pal("Echo server: ~p",[self()]), {ok, #state{n = N}}. handle_msg({ssh_channel_up, ChannelId, ConnectionManager}, State) -> diff --git a/lib/ssh/test/ssh_options_SUITE.erl b/lib/ssh/test/ssh_options_SUITE.erl index ba0107efd6..22a311df3c 100644 --- a/lib/ssh/test/ssh_options_SUITE.erl +++ b/lib/ssh/test/ssh_options_SUITE.erl @@ -51,8 +51,10 @@ ssh_connect_arg4_timeout/1, ssh_connect_negtimeout_parallel/1, ssh_connect_negtimeout_sequential/1, - ssh_connect_nonegtimeout_connected_parallel/1, - ssh_connect_nonegtimeout_connected_sequential/1, + ssh_connect_nonegtimeout_connected_parallel/0, + ssh_connect_nonegtimeout_connected_parallel/1, + ssh_connect_nonegtimeout_connected_sequential/0, + ssh_connect_nonegtimeout_connected_sequential/1, ssh_connect_timeout/1, connect/4, ssh_daemon_minimal_remote_max_packet_size_option/1, ssh_msg_debug_fun_option_client/1, @@ -80,7 +82,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}, - {timetrap,{minutes,6}}]. + {timetrap,{seconds,40}}]. all() -> [connectfun_disconnectfun_server, @@ -980,10 +982,16 @@ ssh_connect_negtimeout(Config, Parallel) -> %%-------------------------------------------------------------------- %%% Test that ssh connection does not timeout if the connection is established (parallel) + +ssh_connect_nonegtimeout_connected_parallel() -> [{timetrap,{seconds,90}}]. + ssh_connect_nonegtimeout_connected_parallel(Config) -> ssh_connect_nonegtimeout_connected(Config, true). %%% Test that ssh connection does not timeout if the connection is established (non-parallel) + +ssh_connect_nonegtimeout_connected_sequential() -> [{timetrap,{seconds,90}}]. + ssh_connect_nonegtimeout_connected_sequential(Config) -> ssh_connect_nonegtimeout_connected(Config, false). diff --git a/lib/ssh/test/ssh_protocol_SUITE.erl b/lib/ssh/test/ssh_protocol_SUITE.erl index dbba48c726..eea71038aa 100644 --- a/lib/ssh/test/ssh_protocol_SUITE.erl +++ b/lib/ssh/test/ssh_protocol_SUITE.erl @@ -43,7 +43,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}, - {timetrap,{minutes,2}}]. + {timetrap,{seconds,40}}]. all() -> [{group,tool_tests}, diff --git a/lib/ssh/test/ssh_renegotiate_SUITE.erl b/lib/ssh/test/ssh_renegotiate_SUITE.erl index 6d2c97aa68..abbe57796f 100644 --- a/lib/ssh/test/ssh_renegotiate_SUITE.erl +++ b/lib/ssh/test/ssh_renegotiate_SUITE.erl @@ -31,7 +31,7 @@ %%-------------------------------------------------------------------- suite() -> [{ct_hooks,[ts_install_cth]}, - {timetrap,{minutes,12}}]. + {timetrap,{seconds,40}}]. all() -> [{group,default_algs}, @@ -83,7 +83,8 @@ end_per_testcase(_TestCase, _Config) -> %%-------------------------------------------------------------------- %%% Idle timeout test - +rekey() -> [{timetrap,{seconds,90}}]. + rekey(Config) -> {Pid, Host, Port} = ssh_test_lib:std_daemon(Config, @@ -105,6 +106,8 @@ rekey(Config) -> %%% Test rekeying by data volume +rekey_limit() -> [{timetrap,{seconds,400}}]. + rekey_limit(Config) -> UserDir = ?config(priv_dir, Config), DataFile = filename:join(UserDir, "rekey.data"), diff --git a/lib/ssh/test/ssh_sftp_SUITE.erl b/lib/ssh/test/ssh_sftp_SUITE.erl index c2b04d7a05..76ba78b728 100644 --- a/lib/ssh/test/ssh_sftp_SUITE.erl +++ b/lib/ssh/test/ssh_sftp_SUITE.erl @@ -36,7 +36,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}, - {timetrap,{minutes,2}}]. + {timetrap,{seconds,40}}]. all() -> diff --git a/lib/ssh/test/ssh_sftpd_SUITE.erl b/lib/ssh/test/ssh_sftpd_SUITE.erl index 45439ce0fa..57b93a5f36 100644 --- a/lib/ssh/test/ssh_sftpd_SUITE.erl +++ b/lib/ssh/test/ssh_sftpd_SUITE.erl @@ -45,7 +45,7 @@ %%-------------------------------------------------------------------- suite() -> - [{timetrap,{minutes,3}}]. + [{timetrap,{seconds,40}}]. all() -> [open_close_file, diff --git a/lib/ssh/test/ssh_sftpd_erlclient_SUITE.erl b/lib/ssh/test/ssh_sftpd_erlclient_SUITE.erl index 02a2ac4cf9..4c3c2dcd5a 100644 --- a/lib/ssh/test/ssh_sftpd_erlclient_SUITE.erl +++ b/lib/ssh/test/ssh_sftpd_erlclient_SUITE.erl @@ -37,7 +37,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}, - {timetrap,{minutes,2}}]. + {timetrap,{seconds,40}}]. all() -> diff --git a/lib/ssh/test/ssh_sup_SUITE.erl b/lib/ssh/test/ssh_sup_SUITE.erl index 18e91a9af3..cbbd7d4d76 100644 --- a/lib/ssh/test/ssh_sup_SUITE.erl +++ b/lib/ssh/test/ssh_sup_SUITE.erl @@ -36,7 +36,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}, - {timetrap,{minutes,1}}]. + {timetrap,{seconds,40}}]. all() -> [default_tree, sshc_subtree, sshd_subtree, sshd_subtree_profile]. diff --git a/lib/ssh/test/ssh_to_openssh_SUITE.erl b/lib/ssh/test/ssh_to_openssh_SUITE.erl index 2788bc6b58..80f8607f65 100644 --- a/lib/ssh/test/ssh_to_openssh_SUITE.erl +++ b/lib/ssh/test/ssh_to_openssh_SUITE.erl @@ -34,7 +34,7 @@ %%-------------------------------------------------------------------- suite() -> - [{timetrap,{minutes,1}}]. + [{timetrap,{seconds,40}}]. all() -> case os:find_executable("ssh") of diff --git a/lib/ssh/test/ssh_upgrade_SUITE.erl b/lib/ssh/test/ssh_upgrade_SUITE.erl index bf8874b118..20df865b55 100644 --- a/lib/ssh/test/ssh_upgrade_SUITE.erl +++ b/lib/ssh/test/ssh_upgrade_SUITE.erl @@ -39,7 +39,7 @@ %%% CommonTest callbacks %%% suite() -> - [{timetrap,{minutes,2}}]. + [{timetrap,{seconds,180}}]. all() -> [ diff --git a/lib/ssl/doc/src/ssl.xml b/lib/ssl/doc/src/ssl.xml index a76d46ee9b..82bede69d0 100644 --- a/lib/ssl/doc/src/ssl.xml +++ b/lib/ssl/doc/src/ssl.xml @@ -48,7 +48,7 @@ <item><p><c>true | false</c></p></item> <tag><c>option() =</c></tag> - <item><p><c>socketoption() | ssloption() | transportoption()</c></p> + <item><p><c>socketoption() | ssl_option() | transport_option()</c></p> </item> <tag><c>socketoption() =</c></tag> @@ -60,7 +60,7 @@ <seealso marker="kernel:gen_tcp">gen_tcp(3)</seealso> manual pages in Kernel.</p></item> - <tag><marker id="type-ssloption"/><c>ssloption() =</c></tag> + <tag><marker id="type-ssloption"/><c>ssl_option() =</c></tag> <item> <p><c>{verify, verify_type()}</c></p> <p><c>| {verify_fun, {fun(), term()}}</c></p> @@ -85,11 +85,11 @@ [binary()]} | {client | server, [binary()], binary()}}</c></p> <p><c>| {log_alert, boolean()}</c></p> <p><c>| {server_name_indication, hostname() | disable}</c></p> - <p><c>| {sni_hosts, [{hostname(), ssloptions()}]}</c></p> + <p><c>| {sni_hosts, [{hostname(), [ssl_option()]}]}</c></p> <p><c>| {sni_fun, SNIfun::fun()}</c></p> </item> - <tag><c>transportoption() =</c></tag> + <tag><c>transport_option() =</c></tag> <item><p><c>{cb_info, {CallbackModule::atom(), DataTag::atom(), ClosedTag::atom(), ErrTag:atom()}}</c></p> @@ -168,7 +168,7 @@ | srp_4096 | srp_6144 | srp_8192</c></p></item> <tag><c>SNIfun::fun()</c></tag> - <item><p><c>= fun(ServerName :: string()) -> ssloptions()</c></p></item> + <item><p><c>= fun(ServerName :: string()) -> [ssl_option()]</c></p></item> </taglist> </section> @@ -617,7 +617,7 @@ fun(srp, Username :: string(), UserState :: term()) -> selection. If set to <c>false</c> (the default), use the client preference.</p></item> - <tag><c>{sni_hosts, [{hostname(), ssloptions()}]}</c></tag> + <tag><c>{sni_hosts, [{hostname(), [ssl_option()]}]}</c></tag> <item><p>If the server receives a SNI (Server Name Indication) from the client matching a host listed in the <c>sni_hosts</c> option, the specific options for that host will override previously specified options. @@ -626,11 +626,11 @@ fun(srp, Username :: string(), UserState :: term()) -> <tag><c>{sni_fun, SNIfun::fun()}</c></tag> <item><p>If the server receives a SNI (Server Name Indication) from the client, - the given function will be called to retrieve <c>ssloptions()</c> for the indicated server. - These options will be merged into predefined <c>ssloptions()</c>. + the given function will be called to retrieve <c>[ssl_option()]</c> for the indicated server. + These options will be merged into predefined <c>[ssl_option()]</c>. The function should be defined as: - <c>fun(ServerName :: string()) -> ssloptions()</c> + <c>fun(ServerName :: string()) -> [ssl_option()]</c> and can be specified as a fun or as named <c>fun module:function/1</c> The option <c>sni_fun</c>, and <c>sni_hosts</c> are mutually exclusive.</p></item> @@ -710,7 +710,7 @@ fun(srp, Username :: string(), UserState :: term()) -> equivalent, connected socket to an SSL socket.</fsummary> <type> <v>Socket = socket()</v> - <v>SslOptions = [ssloption()]</v> + <v>SslOptions = [ssl_option()]</v> <v>Timeout = integer() | infinity</v> <v>SslSocket = sslsocket()</v> <v>Reason = term()</v> @@ -1023,7 +1023,7 @@ fun(srp, Username :: string(), UserState :: term()) -> <fsummary>Performs server-side SSL/TLS handshake.</fsummary> <type> <v>Socket = socket() | sslsocket() </v> - <v>SslOptions = ssloptions()</v> + <v>SslOptions = [ssl_option()]</v> <v>Timeout = integer()</v> <v>Reason = term()</v> </type> diff --git a/lib/ssl/test/ssl_basic_SUITE.erl b/lib/ssl/test/ssl_basic_SUITE.erl index 847a9f19de..f2cf99e8a8 100644 --- a/lib/ssl/test/ssl_basic_SUITE.erl +++ b/lib/ssl/test/ssl_basic_SUITE.erl @@ -4096,7 +4096,7 @@ connection_information_result(Socket) -> {ok, Info = [_ | _]} = ssl:connection_information(Socket), case length(Info) > 3 of true -> - %% Atleast one ssloption() is set + %% Atleast one ssl_option() is set ct:log("Info ~p", [Info]), ok; false -> diff --git a/lib/stdlib/src/filename.erl b/lib/stdlib/src/filename.erl index d921a69108..37f87b1ff9 100644 --- a/lib/stdlib/src/filename.erl +++ b/lib/stdlib/src/filename.erl @@ -1068,24 +1068,43 @@ basedir_darwin(Type) -> %% user_cache %LOCALAPPDATA%[/$author]/$appname[/$version]/Cache %% user_log %LOCALAPPDATA%[/$author]/$appname[/$version]/Logs +-define(basedir_windows_user_data, "Local"). +-define(basedir_windows_user_config, "Roaming"). +-define(basedir_windows_user_cache, "Local"). %% Cache is added later +-define(basedir_windows_user_log, "Local"). %% Logs is added later + basedir_windows(Type) -> %% If LOCALAPPDATA is not defined we are likely on an %% XP machine. Use APPDATA instead. - AppData = basedir_windows_appdata(), - case Type of - user_data -> getenv("LOCALAPPDATA", AppData); - user_config -> AppData; - user_cache -> getenv("LOCALAPPDATA", AppData); - user_log -> getenv("LOCALAPPDATA", AppData); - site_data -> []; - site_config -> [] + case basedir_windows_appdata() of + noappdata -> + %% No AppData is set + %% Probably running MSYS + case Type of + user_data -> basedir_join_home(?basedir_windows_user_data); + user_config -> basedir_join_home(?basedir_windows_user_config); + user_cache -> basedir_join_home(?basedir_windows_user_cache); + user_log -> basedir_join_home(?basedir_windows_user_log); + site_data -> []; + site_config -> [] + end; + {ok, AppData} -> + case Type of + user_data -> getenv("LOCALAPPDATA", AppData); + user_config -> AppData; + user_cache -> getenv("LOCALAPPDATA", AppData); + user_log -> getenv("LOCALAPPDATA", AppData); + site_data -> []; + site_config -> [] + end end. basedir_windows_appdata() -> case os:getenv("APPDATA") of Invalid when Invalid =:= false orelse Invalid =:= [] -> - erlang:error(noappdata); - Val -> Val + noappdata; + Val -> + {ok, Val} end. %% basedir aux diff --git a/lib/stdlib/test/ets_SUITE.erl b/lib/stdlib/test/ets_SUITE.erl index 678c225d25..fd0ff0e252 100644 --- a/lib/stdlib/test/ets_SUITE.erl +++ b/lib/stdlib/test/ets_SUITE.erl @@ -2497,9 +2497,10 @@ rename_unnamed_do(Opts) -> %% Rename a table with many fixations, and at the same time delete it. evil_rename(Config) when is_list(Config) -> - evil_rename_1(old_hash, new_hash, [public,named_table]), EtsMem = etsmem(), + evil_rename_1(old_hash, new_hash, [public,named_table]), evil_rename_1(old_tree, new_tree, [public,ordered_set,named_table]), + wait_for_test_procs(true), verify_etsmem(EtsMem). evil_rename_1(Old, New, Flags) -> @@ -2540,7 +2541,8 @@ crazy_fixtable_wait(N, Dracula) -> crazy_fixtable_1(0, _) -> ok; crazy_fixtable_1(N, Fun) -> - spawn_link(Fun), + %%FIXME my_spawn_link(Fun), + my_spawn_link(Fun), crazy_fixtable_1(N-1, Fun). evil_creater_destroyer() -> @@ -5752,10 +5754,11 @@ spawn_logger(Procs, FailedMemchecks) -> after 0 -> case Kill of true -> exit(Proc, kill); - _ -> ok + _ -> + erlang:display({"Waiting for 'DOWN' from", Proc, + process_info(Proc), + pid_status(Proc)}) end, - erlang:display({"Waiting for 'DOWN' from", Proc, - process_info(Proc), pid_status(Proc)}), receive {'DOWN', Mon, _, _, _} -> ok diff --git a/otp_versions.table b/otp_versions.table index a952e1986f..21b4700c20 100644 --- a/otp_versions.table +++ b/otp_versions.table @@ -14,6 +14,7 @@ OTP-18.0.3 : erts-7.0.3 # asn1-4.0 common_test-1.11 compiler-6.0 cosEvent-2.2 co OTP-18.0.2 : erts-7.0.2 runtime_tools-1.9.1 # asn1-4.0 common_test-1.11 compiler-6.0 cosEvent-2.2 cosEventDomain-1.2 cosFileTransfer-1.2 cosNotification-1.2 cosProperty-1.2 cosTime-1.2 cosTransactions-1.3 crypto-3.6 debugger-4.1 dialyzer-2.8 diameter-1.10 edoc-0.7.17 eldap-1.2 erl_docgen-0.4 erl_interface-3.8 et-1.5.1 eunit-2.2.10 gs-1.6 hipe-3.12 ic-4.4 inets-6.0 jinterface-1.6 kernel-4.0 megaco-3.18 mnesia-4.13 observer-2.1 odbc-2.11 orber-3.8 os_mon-2.4 ose-1.1 otp_mibs-1.1 parsetools-2.1 percept-0.8.11 public_key-1.0 reltool-0.7 sasl-2.5 snmp-5.2 ssh-4.0 ssl-7.0 stdlib-2.5 syntax_tools-1.7 test_server-3.9 tools-2.8 typer-0.9.9 webtool-0.9 wx-1.4 xmerl-1.3.8 : OTP-18.0.1 : erts-7.0.1 # asn1-4.0 common_test-1.11 compiler-6.0 cosEvent-2.2 cosEventDomain-1.2 cosFileTransfer-1.2 cosNotification-1.2 cosProperty-1.2 cosTime-1.2 cosTransactions-1.3 crypto-3.6 debugger-4.1 dialyzer-2.8 diameter-1.10 edoc-0.7.17 eldap-1.2 erl_docgen-0.4 erl_interface-3.8 et-1.5.1 eunit-2.2.10 gs-1.6 hipe-3.12 ic-4.4 inets-6.0 jinterface-1.6 kernel-4.0 megaco-3.18 mnesia-4.13 observer-2.1 odbc-2.11 orber-3.8 os_mon-2.4 ose-1.1 otp_mibs-1.1 parsetools-2.1 percept-0.8.11 public_key-1.0 reltool-0.7 runtime_tools-1.9 sasl-2.5 snmp-5.2 ssh-4.0 ssl-7.0 stdlib-2.5 syntax_tools-1.7 test_server-3.9 tools-2.8 typer-0.9.9 webtool-0.9 wx-1.4 xmerl-1.3.8 : OTP-18.0 : asn1-4.0 common_test-1.11 compiler-6.0 cosEvent-2.2 cosEventDomain-1.2 cosFileTransfer-1.2 cosNotification-1.2 cosProperty-1.2 cosTime-1.2 cosTransactions-1.3 crypto-3.6 debugger-4.1 dialyzer-2.8 diameter-1.10 edoc-0.7.17 eldap-1.2 erl_docgen-0.4 erl_interface-3.8 erts-7.0 et-1.5.1 eunit-2.2.10 gs-1.6 hipe-3.12 ic-4.4 inets-6.0 jinterface-1.6 kernel-4.0 megaco-3.18 mnesia-4.13 observer-2.1 odbc-2.11 orber-3.8 os_mon-2.4 ose-1.1 otp_mibs-1.1 parsetools-2.1 percept-0.8.11 public_key-1.0 reltool-0.7 runtime_tools-1.9 sasl-2.5 snmp-5.2 ssh-4.0 ssl-7.0 stdlib-2.5 syntax_tools-1.7 test_server-3.9 tools-2.8 typer-0.9.9 webtool-0.9 wx-1.4 xmerl-1.3.8 # : +OTP-17.5.6.9 : diameter-1.9.2.4 erts-6.4.1.6 ssl-6.0.1.2 # asn1-3.0.4 common_test-1.10.1 compiler-5.0.4 cosEvent-2.1.15 cosEventDomain-1.1.14 cosFileTransfer-1.1.16 cosNotification-1.1.21 cosProperty-1.1.17 cosTime-1.1.14 cosTransactions-1.2.14 crypto-3.5 debugger-4.0.3.1 dialyzer-2.7.4 edoc-0.7.16 eldap-1.1.1 erl_docgen-0.3.7 erl_interface-3.7.20 et-1.5 eunit-2.2.9 gs-1.5.16 hipe-3.11.3 ic-4.3.6 inets-5.10.9 jinterface-1.5.12 kernel-3.2.0.1 megaco-3.17.3 mnesia-4.12.5 observer-2.0.4 odbc-2.10.22 orber-3.7.1 os_mon-2.3.1 ose-1.0.2 otp_mibs-1.0.10 parsetools-2.0.12 percept-0.8.10 public_key-0.23 reltool-0.6.6 runtime_tools-1.8.16.1 sasl-2.4.1 snmp-5.1.2 ssh-3.2.4 stdlib-2.4 syntax_tools-1.6.18 test_server-3.8.1 tools-2.7.2 typer-0.9.8 webtool-0.8.10 wx-1.3.3 xmerl-1.3.7 : OTP-17.5.6.8 : diameter-1.9.2.3 # asn1-3.0.4 common_test-1.10.1 compiler-5.0.4 cosEvent-2.1.15 cosEventDomain-1.1.14 cosFileTransfer-1.1.16 cosNotification-1.1.21 cosProperty-1.1.17 cosTime-1.1.14 cosTransactions-1.2.14 crypto-3.5 debugger-4.0.3.1 dialyzer-2.7.4 edoc-0.7.16 eldap-1.1.1 erl_docgen-0.3.7 erl_interface-3.7.20 erts-6.4.1.5 et-1.5 eunit-2.2.9 gs-1.5.16 hipe-3.11.3 ic-4.3.6 inets-5.10.9 jinterface-1.5.12 kernel-3.2.0.1 megaco-3.17.3 mnesia-4.12.5 observer-2.0.4 odbc-2.10.22 orber-3.7.1 os_mon-2.3.1 ose-1.0.2 otp_mibs-1.0.10 parsetools-2.0.12 percept-0.8.10 public_key-0.23 reltool-0.6.6 runtime_tools-1.8.16.1 sasl-2.4.1 snmp-5.1.2 ssh-3.2.4 ssl-6.0.1.1 stdlib-2.4 syntax_tools-1.6.18 test_server-3.8.1 tools-2.7.2 typer-0.9.8 webtool-0.8.10 wx-1.3.3 xmerl-1.3.7 : OTP-17.5.6.7 : diameter-1.9.2.2 # asn1-3.0.4 common_test-1.10.1 compiler-5.0.4 cosEvent-2.1.15 cosEventDomain-1.1.14 cosFileTransfer-1.1.16 cosNotification-1.1.21 cosProperty-1.1.17 cosTime-1.1.14 cosTransactions-1.2.14 crypto-3.5 debugger-4.0.3.1 dialyzer-2.7.4 edoc-0.7.16 eldap-1.1.1 erl_docgen-0.3.7 erl_interface-3.7.20 erts-6.4.1.5 et-1.5 eunit-2.2.9 gs-1.5.16 hipe-3.11.3 ic-4.3.6 inets-5.10.9 jinterface-1.5.12 kernel-3.2.0.1 megaco-3.17.3 mnesia-4.12.5 observer-2.0.4 odbc-2.10.22 orber-3.7.1 os_mon-2.3.1 ose-1.0.2 otp_mibs-1.0.10 parsetools-2.0.12 percept-0.8.10 public_key-0.23 reltool-0.6.6 runtime_tools-1.8.16.1 sasl-2.4.1 snmp-5.1.2 ssh-3.2.4 ssl-6.0.1.1 stdlib-2.4 syntax_tools-1.6.18 test_server-3.8.1 tools-2.7.2 typer-0.9.8 webtool-0.8.10 wx-1.3.3 xmerl-1.3.7 : OTP-17.5.6.6 : erts-6.4.1.5 # asn1-3.0.4 common_test-1.10.1 compiler-5.0.4 cosEvent-2.1.15 cosEventDomain-1.1.14 cosFileTransfer-1.1.16 cosNotification-1.1.21 cosProperty-1.1.17 cosTime-1.1.14 cosTransactions-1.2.14 crypto-3.5 debugger-4.0.3.1 dialyzer-2.7.4 diameter-1.9.2.1 edoc-0.7.16 eldap-1.1.1 erl_docgen-0.3.7 erl_interface-3.7.20 et-1.5 eunit-2.2.9 gs-1.5.16 hipe-3.11.3 ic-4.3.6 inets-5.10.9 jinterface-1.5.12 kernel-3.2.0.1 megaco-3.17.3 mnesia-4.12.5 observer-2.0.4 odbc-2.10.22 orber-3.7.1 os_mon-2.3.1 ose-1.0.2 otp_mibs-1.0.10 parsetools-2.0.12 percept-0.8.10 public_key-0.23 reltool-0.6.6 runtime_tools-1.8.16.1 sasl-2.4.1 snmp-5.1.2 ssh-3.2.4 ssl-6.0.1.1 stdlib-2.4 syntax_tools-1.6.18 test_server-3.8.1 tools-2.7.2 typer-0.9.8 webtool-0.8.10 wx-1.3.3 xmerl-1.3.7 : |