mirror of
https://github.com/moses-smt/mosesdecoder.git
synced 2025-01-02 17:09:36 +03:00
337 lines
10 KiB
Plaintext
337 lines
10 KiB
Plaintext
# Copyright 2001, 2002, 2003 Dave Abrahams
|
|
# Copyright 2006 Rene Rivera
|
|
# Copyright 2002, 2003 Vladimir Prus
|
|
# Distributed under the Boost Software License, Version 1.0.
|
|
# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
import errors ;
|
|
import modules ;
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# Private implementation details.
|
|
#
|
|
################################################################################
|
|
|
|
# Rule added as a replacement for the regular Jam = operator but which does not
|
|
# ignore trailing empty string elements.
|
|
#
|
|
local rule exact-equal-test ( lhs * : rhs * )
|
|
{
|
|
local lhs_extended = $(lhs) xxx ;
|
|
local rhs_extended = $(rhs) xxx ;
|
|
if $(lhs_extended) = $(rhs_extended)
|
|
{
|
|
return true ;
|
|
}
|
|
}
|
|
|
|
|
|
# Two lists are considered set-equal if they contain the same elements, ignoring
|
|
# duplicates and ordering.
|
|
#
|
|
local rule set-equal-test ( set1 * : set2 * )
|
|
{
|
|
if ( $(set1) in $(set2) ) && ( $(set2) in $(set1) )
|
|
{
|
|
return true ;
|
|
}
|
|
}
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# Public interface.
|
|
#
|
|
################################################################################
|
|
|
|
# Assert the equality of A and B, ignoring trailing empty string elements.
|
|
#
|
|
rule equal ( a * : b * )
|
|
{
|
|
if $(a) != $(b)
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: \"$(a)\" "==" \"$(b)\"
|
|
(ignoring trailing empty strings) ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert that the result of calling RULE-NAME on the given arguments has a false
|
|
# logical value (is either an empty list or all empty strings).
|
|
#
|
|
rule false ( rule-name args * : * )
|
|
{
|
|
local result ;
|
|
module [ CALLER_MODULE ]
|
|
{
|
|
modules.poke assert : result : [ $(1) : $(2) : $(3) : $(4) : $(5) : $(6)
|
|
: $(7) : $(8) : $(9) ] ;
|
|
}
|
|
|
|
if $(result)
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: Expected false result from
|
|
"[" $(rule-name) [ errors.lol->list $(args) : $(2) : $(3) : $(4) :
|
|
$(5) : $(6) : $(7) : $(8) : $(9) ] "]" : Got: "[" \"$(result)\" "]" ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert that ELEMENT is present in LIST.
|
|
#
|
|
rule "in" ( element : list * )
|
|
{
|
|
if ! $(element) in $(list)
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: Expected \"$(element)\" in
|
|
"[" \"$(list)\" "]" ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert the inequality of A and B, ignoring trailing empty string elements.
|
|
#
|
|
rule not-equal ( a * : b * )
|
|
{
|
|
if $(a) = $(b)
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: \"$(a)\" "!=" \"$(b)\"
|
|
(ignoring trailing empty strings) ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert that ELEMENT is not present in LIST.
|
|
#
|
|
rule not-in ( element : list * )
|
|
{
|
|
if $(element) in $(list)
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: Did not expect
|
|
\"$(element)\" in "[" \"$(list)\" "]" ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert the inequality of A and B as sets.
|
|
#
|
|
rule not-set-equal ( a * : b * )
|
|
{
|
|
if [ set-equal-test $(a) : $(b) ]
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: Expected "[" \"$(a)\" "]"
|
|
and "[" \"$(b)\" "]" to not be equal as sets ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert that A and B are not exactly equal, not ignoring trailing empty string
|
|
# elements.
|
|
#
|
|
rule not-exact-equal ( a * : b * )
|
|
{
|
|
if [ exact-equal-test $(a) : $(b) ]
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: \"$(a)\" "!=" \"$(b)\" ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert that EXPECTED is the result of calling RULE-NAME with the given
|
|
# arguments.
|
|
#
|
|
rule result ( expected * : rule-name args * : * )
|
|
{
|
|
local result ;
|
|
module [ CALLER_MODULE ]
|
|
{
|
|
modules.poke assert : result : [ $(2) : $(3) : $(4) : $(5) : $(6) : $(7)
|
|
: $(8) : $(9) ] ;
|
|
}
|
|
|
|
if ! [ exact-equal-test $(result) : $(expected) ]
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: "[" $(rule-name) [
|
|
errors.lol->list $(args) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) :
|
|
$(9) ] "]" : Expected: "[" \"$(expected)\" "]" : Got: "["
|
|
\"$(result)\" "]" ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert that EXPECTED is set-equal (i.e. duplicates and ordering are ignored)
|
|
# to the result of calling RULE-NAME with the given arguments. Note that rules
|
|
# called this way may accept at most 8 parameters.
|
|
#
|
|
rule result-set-equal ( expected * : rule-name args * : * )
|
|
{
|
|
local result ;
|
|
module [ CALLER_MODULE ]
|
|
{
|
|
modules.poke assert : result : [ $(2) : $(3) : $(4) : $(5) : $(6) : $(7)
|
|
: $(8) : $(9) ] ;
|
|
}
|
|
|
|
if ! [ set-equal-test $(result) : $(expected) ]
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: "[" $(rule-name) [
|
|
errors.lol->list $(args) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) :
|
|
$(9) ] "]" : Expected: "[" \"$(expected)\" "]" : Got: "["
|
|
\"$(result)\" "]" ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert the equality of A and B as sets.
|
|
#
|
|
rule set-equal ( a * : b * )
|
|
{
|
|
if ! [ set-equal-test $(a) : $(b) ]
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: Expected "[" \"$(a)\" "]"
|
|
and "[" \"$(b)\" "]" to be equal as sets ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert that the result of calling RULE-NAME on the given arguments has a true
|
|
# logical value (is neither an empty list nor all empty strings).
|
|
#
|
|
rule true ( rule-name args * : * )
|
|
{
|
|
local result ;
|
|
module [ CALLER_MODULE ]
|
|
{
|
|
modules.poke assert : result : [ $(1) : $(2) : $(3) : $(4) : $(5) : $(6)
|
|
: $(7) : $(8) : $(9) ] ;
|
|
}
|
|
|
|
if ! $(result)
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: Expected true result from
|
|
"[" $(rule-name) [ errors.lol->list $(args) : $(2) : $(3) : $(4) :
|
|
$(5) : $(6) : $(7) : $(8) : $(9) ] "]" ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert the exact equality of A and B, not ignoring trailing empty string
|
|
# elements.
|
|
#
|
|
rule exact-equal ( a * : b * )
|
|
{
|
|
if ! [ exact-equal-test $(a) : $(b) ]
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: \"$(a)\" "==" \"$(b)\" ;
|
|
}
|
|
}
|
|
|
|
|
|
# Assert that the given variable is not an empty list.
|
|
#
|
|
rule variable-not-empty ( name )
|
|
{
|
|
local value = [ modules.peek [ CALLER_MODULE ] : $(name) ] ;
|
|
if ! $(value)-is-not-empty
|
|
{
|
|
errors.error-skip-frames 3 assertion failure: Expected variable
|
|
\"$(name)\" not to be an empty list ;
|
|
}
|
|
}
|
|
|
|
|
|
rule __test__ ( )
|
|
{
|
|
# Helper rule used to avoid test duplication related to different list
|
|
# equality test rules.
|
|
#
|
|
local rule run-equality-test ( equality-assert : ignore-trailing-empty-strings ? )
|
|
{
|
|
local not-equality-assert = not-$(equality-assert) ;
|
|
|
|
# When the given equality test is expected to ignore trailing empty
|
|
# strings some of the test results should be inverted.
|
|
local not-equality-assert-i = not-$(equality-assert) ;
|
|
if $(ignore-trailing-empty-strings)
|
|
{
|
|
not-equality-assert-i = $(equality-assert) ;
|
|
}
|
|
|
|
$(equality-assert) : ;
|
|
$(equality-assert) "" "" : "" "" ;
|
|
$(not-equality-assert-i) : "" "" ;
|
|
$(equality-assert) x : x ;
|
|
$(not-equality-assert) : x ;
|
|
$(not-equality-assert) "" : x ;
|
|
$(not-equality-assert) "" "" : x ;
|
|
$(not-equality-assert-i) x : x "" ;
|
|
$(equality-assert) x "" : x "" ;
|
|
$(not-equality-assert) x : "" x ;
|
|
$(equality-assert) "" x : "" x ;
|
|
|
|
$(equality-assert) 1 2 3 : 1 2 3 ;
|
|
$(not-equality-assert) 1 2 3 : 3 2 1 ;
|
|
$(not-equality-assert) 1 2 3 : 1 5 3 ;
|
|
$(not-equality-assert) 1 2 3 : 1 "" 3 ;
|
|
$(not-equality-assert) 1 2 3 : 1 1 2 3 ;
|
|
$(not-equality-assert) 1 2 3 : 1 2 2 3 ;
|
|
$(not-equality-assert) 1 2 3 : 5 6 7 ;
|
|
|
|
# Extra variables used here just to make sure Boost Jam or Boost Build
|
|
# do not handle lists with empty strings differently depending on
|
|
# whether they are literals or stored in variables.
|
|
|
|
local empty = ;
|
|
local empty-strings = "" "" ;
|
|
local x-empty-strings = x "" "" ;
|
|
local empty-strings-x = "" "" x ;
|
|
|
|
$(equality-assert) : $(empty) ;
|
|
$(not-equality-assert-i) "" : $(empty) ;
|
|
$(not-equality-assert-i) "" "" : $(empty) ;
|
|
$(not-equality-assert-i) : $(empty-strings) ;
|
|
$(not-equality-assert-i) "" : $(empty-strings) ;
|
|
$(equality-assert) "" "" : $(empty-strings) ;
|
|
$(equality-assert) $(empty) : $(empty) ;
|
|
$(equality-assert) $(empty-strings) : $(empty-strings) ;
|
|
$(not-equality-assert-i) $(empty) : $(empty-strings) ;
|
|
$(equality-assert) $(x-empty-strings) : $(x-empty-strings) ;
|
|
$(equality-assert) $(empty-strings-x) : $(empty-strings-x) ;
|
|
$(not-equality-assert) $(empty-strings-x) : $(x-empty-strings) ;
|
|
$(not-equality-assert-i) x : $(x-empty-strings) ;
|
|
$(not-equality-assert) x : $(empty-strings-x) ;
|
|
$(not-equality-assert-i) x : $(x-empty-strings) ;
|
|
$(not-equality-assert-i) x "" : $(x-empty-strings) ;
|
|
$(equality-assert) x "" "" : $(x-empty-strings) ;
|
|
$(not-equality-assert) x : $(empty-strings-x) ;
|
|
$(not-equality-assert) "" x : $(empty-strings-x) ;
|
|
$(equality-assert) "" "" x : $(empty-strings-x) ;
|
|
}
|
|
|
|
|
|
# ---------------
|
|
# Equality tests.
|
|
# ---------------
|
|
|
|
run-equality-test equal : ignore-trailing-empty-strings ;
|
|
run-equality-test exact-equal ;
|
|
|
|
|
|
# -------------------------
|
|
# assert.set-equal() tests.
|
|
# -------------------------
|
|
|
|
set-equal : ;
|
|
not-set-equal "" "" : ;
|
|
set-equal "" "" : "" ;
|
|
set-equal "" "" : "" "" ;
|
|
set-equal a b c : a b c ;
|
|
set-equal a b c : b c a ;
|
|
set-equal a b c a : a b c ;
|
|
set-equal a b c : a b c a ;
|
|
not-set-equal a b c : a b c d ;
|
|
not-set-equal a b c d : a b c ;
|
|
}
|