Ticket #803: pcampalani_makecheck.log

ret=0; \
        for testcase in  ls -d testcases_mandatory/* testcases_open/* testcases_fixed/* testcases_services/*; do\
                PATH=/home/rasdaman/install/bin:/home/rasdaman/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/home/rasdaman/install/bin:/usr/lib/postgresql/9.1/bin:\
                PROGTEST=${testcase}/*.sh;\
                if [ ! -f $testcase/*.sh ]; then\
                        continue;\
                fi;\
                echo; \
                echo; \
                $testcase/*.sh;\
                tmp=$?;\
                if [ $tmp -eq 2 ]; then\
                        echo ${PROGTEST} ... SKIPPED>>logtmp;\
                elif [ $tmp -ne 0 ]; then\
                        ret=$tmp;\
                        echo ${PROGTEST} ... FAIL>>logtmp;\
                else \
                        echo ${PROGTEST} ... OK>>logtmp;\
                fi; \
                echo "  "see detail in $testcase/log>>logtmp;\
        done;\
        echo -e "\n\nTEST SUMMARY\n";\
        cat logtmp;\
        rm logtmp;\
        exit $ret;


Old logfile found, copying it to /home/rasdaman/rasdaman/systemtest/testcases_mandatory/test_conversion/log.save
test.sh: starting test at Tue Jul  1 13:15:58 CEST 2014
test.sh: 
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: default nodata value test passed.
test.sh: custom nodata value test passed.
test.sh: ----- jpeg and inv_jpeg conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output do not match
test.sh: ----- jpeg and decode conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... failed.
test.sh: selecting data... ok.
test.sh: comparing images: input and output do not match
test.sh: ----- jpeg and decode conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... failed.
test.sh: selecting data... ok.
test.sh: comparing images: input and output do not match
test.sh: ----- tiff and inv_tiff conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... failed.
test.sh: selecting data... ok.
test.sh: comparing images: input and output do not match
test.sh: ----- tiff and inv_tiff conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... failed.
test.sh: selecting data... ok.
test.sh: comparing images: input and output do not match
test.sh: ----- tiff and decode conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... failed.
test.sh: comparing images: input and output do not match
test.sh: ----- tiff and decode conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... failed.
test.sh: comparing images: input and output do not match
test.sh: ----- user-defined type conversion ------
test.sh: creating collection... ok.
test.sh: user-defined base type cast inv_tiff test failed.
test.sh: user-defined base type cast decode test passed.
test.sh: user-defined base type inv_tiff test failed.
test.sh: ----- png and inv_png conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- png and decode conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- png and decode conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- bmp and inv_bmp conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- bmp and decode conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- vff and inv_vff conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ------ GML in JPEG2000 conversion --------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
input and output match
test.sh: ----- csv and inv_png conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- csv and inv_png conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- csv and decode conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- csv and decode conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- encode and inv_png conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- csv and conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match
test.sh: ----- csv with inner_outer order conversion ------
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: selecting data... ok.
test.sh: comparing images: input and output match

test.sh: -------------------------------------------------------
test.sh: Test summary
test.sh: 
test.sh:   Test finished at: Tue Jul  1 13:16:16 CEST 2014
test.sh:   Total tests run : 26
test.sh:   Successful tests: 17
test.sh:   Failed tests    : 9
test.sh:   Skipped tests   : 0
test.sh:   Detail test log : /home/rasdaman/rasdaman/systemtest/testcases_mandatory/test_conversion/log
test.sh: -------------------------------------------------------


test.sh: starting test at Tue Jul  1 13:16:16 CEST 2014
test.sh: 
test.sh: test initialization...ok.
test.sh: creating collection... ok.
test.sh: inserting MDD into collection... ok.
test.sh: updating MDD from collection... ok.
test.sh: testing SELECT INTO a new collection... ok.
test.sh: delete all MDDs from a collection... ok.
test.sh: dropping collection test_tmp_select_into... ok.
test.sh: deleting MDD from collection... ok.
test.sh: dropping collection test_tmp... ok.

test.sh: -------------------------------------------------------
test.sh: Test summary
test.sh: 
test.sh:   Test finished at: Tue Jul  1 13:16:17 CEST 2014
test.sh:   Total tests run : 7
test.sh:   Successful tests: 7
test.sh:   Failed tests    : 0
test.sh:   Skipped tests   : 0
test.sh:   Detail test log : /home/rasdaman/rasdaman/systemtest/testcases_mandatory/test_manipulation/log
test.sh: -------------------------------------------------------


test.sh: starting test at Tue Jul  1 13:16:17 CEST 2014
test.sh: 
test.sh: Testing service: select
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: creating collection... ok.
test.sh: inserting data... ok.

running test: array_constants.rasql

select < [-1:1,-2:2] 0, 1, 2, 3, 4; 1, 2, 3, 4, 5; 2, 3, 4, 5, 6 > from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: atomic_constants_char.rasql

select 24c from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: atomic_constants_double.rasql

select 24d from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: atomic_constants_e.rasql

select 4e-5D from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: atomic_constants_float.rasql

select 24f from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: atomic_constants_long.rasql

select 24l from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: atomic_constants_octet.rasql

select 24o from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: atomic_constants_short.rasql

select 24s from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: atomic_constants_ulong.rasql

select 24ul from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: atomic_constants_ushort.rasql

select 24us from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: basic_query_mechanism.rasql

select test_grey[100:150,40:80] / 2 from test_grey where some_cells( test_grey[120:160, 55:75] > 250 )
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: binary_induction_1.rasql

select test_rgb2.1 - test_rgb2.2 from test_rgb2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: binary_induction.rasql

select test_grey - test_grey2 from test_grey, test_grey2

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: case_baseType.rasql

select case when test_grey2>0 then 1c else 0c end from test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: case_expression.rasql

select case when test_grey2>0 then log(test_grey2) else 0 end from test_grey2
test.sh: byte comparison
test.sh:  ->  TEST FAILED
--------------------------------------------------------------------------------------------
running test: case_scalar.rasql

select case when avg_cells(test_grey2)>39 then 1c else 0c end from test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: cast_1.rasql

select (long) test_rgb2 from test_rgb2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: cast.rasql

select (float) avg_cells( test_grey ) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: cast_user_type.rasql

select (RGBPixel) {1234, 8, 23.5}

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: comments_in_queries.rasql

select test_grey -- this comment text is ignored by rasdaman
from test_grey   -- for comments spanning several lines,
          -- every line needs a separate '--' starter
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: common_subexpressions.rasql

select (test_grey + test_grey) - (test_grey + test_grey) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: composite_constants_complex_integer.rasql

select complex( 42, 73 ) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: composite_constants_complex.rasql

select complex( 0.35, 16.0 ) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: composite_constants_struct.rasql

select struct{ struct{ 1l, 2l, 3l }, true } from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: concat.rasql

select concat test_grey with test_grey along 0 from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: condensers_add_complex.rasql

select add_cells( test_complex ) from test_complex

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: condensers_add.rasql

select add_cells( test_grey ) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: condensers_all.rasql

select test_grey from test_grey where all_cells( test_grey > 20 )
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: condensers_avg.rasql

select avg_cells( test_grey ) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: condensers_count.rasql

select count_cells( test_grey >-1) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: condensers_max.rasql

select max_cells( test_grey ) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: condensers_min.rasql

select min_cells( test_grey ) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: condensers_some.rasql

select test_grey from test_grey where some_cells( test_grey[120:160, 55:75] > 250 )
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: extending_a_spatial_domain.rasql

select extend( test_grey, [-1000:1000,-500:500] ) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: from_clause_omitted.rasql

select 0.2 + sin(10)

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: from_clause.rasql

select a - b from test_grey as a, test_grey2 as b
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_condenser_add.rasql

select condense + over x in sdom(a) using a[x] from test_grey as a
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_condenser_all.rasql

select condense and over x in sdom(a) using a[x] from test_grey as a
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_condenser_count.rasql

select condense + over x in sdom(a) where (bool)((bool)a[x]+1) using 1 from test_grey as a

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_condenser_max_double.rasql

select csv(marray i in [-1:1] values condense max over j in [3:4] using (i[0] * j[0]) / 2.0) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_condenser_max.rasql

select csv(marray i in [-1:1] values condense max over j in [3:4] using i[0] * j[0]) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_condenser_min_double.rasql

select csv(marray i in [-1:1] values condense min over j in [3:4] using (i[0] * j[0]) / 2.0) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_condenser_min.rasql

select csv(marray i in [-1:1] values condense min over j in [3:4] using i[0] * j[0]) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_condenser_mult.rasql

select condense * over i in sdom(data) using data[i] from test_complex as data

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_condenser_some.rasql

select condense or over x in sdom(a) using a[x] from test_grey as a
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_constructor_1c.rasql

select marray x in [ 1:100, -50:200 ] values 1c from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_constructor_variable_1.rasql

select marray xy in [1:5, 1:10] values a[ xy[0], xy[1] ] from test_grey as a
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_constructor_variable.rasql

select max_cells(marray x in [100:105], y in [100:105] values a[ x[0], y[0] ]) from test_grey as a

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: general_array_constructor_x[0].rasql

select marray x in [ 0:255, 0:511 ] values x[0] from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induced_and_struct.rasql

select test_rgb2 + 5 from test_rgb2

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_abs.rasql

select abs(test_grey) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_and.rasql

select test_grey and test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_arccos.rasql

select arccos(0.5) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_arcsin.rasql

select arcsin(0.5) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_arctan.rasql

select arctan(1) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_bit.rasql

select bit(test_grey,1) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_complex.rasql

select complex(cos(x), -sin(x)) from test_grey as x

test.sh: byte comparison
test.sh:  ->  TEST FAILED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_cosh.rasql

select cosh(0) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_cos.rasql

select cos(60) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_divide.rasql

select test_grey / test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_egt.rasql

select test_grey >= test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_elt.rasql

select test_grey <= test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_exp.rasql

select exp(0) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_gt.rasql

select test_grey > test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_int_divide.rasql

select div(test_grey, test_grey2) from test_grey, test_grey2

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_is.rasql

select test_grey is test_grey2 from test_grey, test_grey2

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_ln.rasql

select ln(1) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_log.rasql

select log(1) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_lt.rasql

select test_grey < test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_max.rasql

select max_cell(test_grey max 255) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_min.rasql

select max_cell(test_grey min -1) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_modulo.rasql

select mod(test_grey, test_grey2) from test_grey, test_grey2

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_multiply.rasql

select test_grey * test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_ne.rasql

select test_grey != test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_not.rasql

select not(test_grey) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_or.rasql

select test_grey or test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_overlay.rasql

select test_grey overlay test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_pow_const.rasql

select pow(2, 3.5) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_pow.rasql

select pow(test_grey, 2) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_-.rasql

select test_grey - test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_+.rasql

select test_grey + test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_sinh.rasql

select sinh(0) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_sin.rasql

select sin(test_grey) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_sqrt.rasql

select sqrt(test_grey) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_tanh.rasql

select tanh(0) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_tan.rasql

select tan(0) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: induction_all_operations_xor.rasql

select test_grey xor test_grey2 from test_grey, test_grey2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: integer_division.rasql

select div(3, 2) from test_rgb2

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: integer_modulo.rasql

select mod(5,3) from test_rgb2

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: multidimensional_intervals_[1].lo.rasql

select [ -17 : 245, 42 : 227 ][ 1 ].lo from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: multidimensional_intervals_[1].rasql

select [ -17 : 245, 42 : 227 ][ 1 ] from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: multidimensional_intervals.rasql

select [ -17 : 245, 42 : 227 ] from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: object_identifiers.rasql

select test_grey from test_grey where oid( test_grey ) > 10
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: oid.rasql

select oid(test_grey)/oid(test_grey) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: point_select_empty.rasql

select c[500,500] from test_rgb2 as c

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: regular_division.rasql

select 2/3 from test_rgb2 as a

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: scaling_1.rasql

select scale( test_grey, [ 4, 3 ] ) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: scaling_2.rasql

select scale( test_grey, 0.5 ) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: scaling_and_trimming.rasql

select scale(c[124:125,127:128], [0:5,0:2])[1:2,2] from  test_grey AS c

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: section.rasql

select test_grey[ 100, 150 ] from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: select_clause.rasql

select test_grey/2 from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: shifting_a_spatial_domain.rasql

select shift( test_grey[ 0:10, 0:20 ], [ 3, 4 ] ) from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: spatial_domain_[0].hi_as_index.rasql

select test_grey[sdom(test_grey)[0].hi,0] from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: spatial_domain_[0].hi.rasql

select sdom(test_grey)[0].hi from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: spatial_domain_[0].lo.rasql

select sdom(test_grey)[0].lo from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: spatial_domain_[0].rasql

select sdom(test_grey)[0] from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: spatial_domain.rasql

select sdom(test_grey) from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: struct_component_selection_1.rasql

select test_rgb2.1 from test_rgb2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: struct_component_selection_2.rasql

select test_rgb2 / 2c from test_rgb2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: struct_component_selection.rasql

select test_rgb2.2 from test_rgb2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: the_array_bound_asterisk_1.rasql

select test_grey[ *:*, 10:150 ] from test_grey

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: the_array_bound_asterisk.rasql

select test_grey[ 50:*, *:200 ] from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: trimming.rasql

select test_grey[ 120:160, 55:75 ] from test_grey
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: unary_induction.rasql

select test_rgb2.1 * 2c from test_rgb2
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: where_clause.rasql

select test_grey - test_grey2 from test_grey, test_grey2 where some_cells( test_grey - test_grey2 > 50 )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------

test.sh: -------------------------------------------------------
test.sh: Test summary
test.sh: 
test.sh:   Test finished at: Tue Jul  1 13:16:55 CEST 2014
test.sh:   Total tests run : 115
test.sh:   Successful tests: 113
test.sh:   Failed tests    : 2
test.sh:   Skipped tests   : 0
test.sh:   Detail test log : /home/rasdaman/rasdaman/systemtest/testcases_mandatory/test_select/log
test.sh: -------------------------------------------------------


test.sh: starting test at Tue Jul  1 13:16:55 CEST 2014
test.sh: 
----------------------------------------------------------------------

test.sh: running queries in 001-regular_tiling_2D_rc-index.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 001-regular_tiling_2D_rc-index.rasql.0:
test.sh:   insert into test_coll values marray i in [0:19,0:19] values 1c tiling regular [0:9,0:9] tile size 100 index rc_index
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 001-regular_tiling_2D_rc-index.rasql.1:
test.sh:   update test_coll as m set m assign marray i in [0:19,0:19] values 2c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 001-regular_tiling_2D_rc-index.rasql.2:
test.sh:   update test_coll as m set m assign marray i in [10:19,0:19] values 3c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------

test.sh: running queries in 002-regular_tiling_2D_rpt-index.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 002-regular_tiling_2D_rpt-index.rasql.0:
test.sh:   insert into test_coll values marray i in [0:19,0:19] values 1c tiling regular [0:9,0:9] tile size 100 index rpt_index
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 002-regular_tiling_2D_rpt-index.rasql.1:
test.sh:   update test_coll as m set m assign marray i in [0:19,0:19] values 2c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 002-regular_tiling_2D_rpt-index.rasql.2:
test.sh:   update test_coll as m set m assign marray i in [10:19,0:19] values 3c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 002-regular_tiling_2D_rpt-index.rasql.3:
test.sh:   update test_coll as m set m assign marray i in [10:29,10:29] values 4c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 002-regular_tiling_2D_rpt-index.rasql.4:
test.sh:   update test_coll as m set m assign marray i in [20:39,0:19] values 5c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 002-regular_tiling_2D_rpt-index.rasql.5:
test.sh:   update test_coll as m set m assign marray i in [0:39,0:39] values 6c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 002-regular_tiling_2D_rpt-index.rasql.6:
test.sh:   update test_coll as m set m assign marray i in [20:39,0:39] values 7c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------

test.sh: running queries in 003-aligned_tiling_2D_rpt-index.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 003-aligned_tiling_2D_rpt-index.rasql.0:
test.sh:   insert into test_coll values marray i in [0:19,0:19] values 1c tiling aligned [0:9,0:9] tile size 100 index rpt_index
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 003-aligned_tiling_2D_rpt-index.rasql.1:
test.sh:   update test_coll as m set m assign marray i in [0:19,0:19] values 2c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 003-aligned_tiling_2D_rpt-index.rasql.2:
test.sh:   update test_coll as m set m assign marray i in [10:19,0:19] values 3c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 003-aligned_tiling_2D_rpt-index.rasql.3:
test.sh:   update test_coll as m set m assign marray i in [10:29,10:29] values 4c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 003-aligned_tiling_2D_rpt-index.rasql.4:
test.sh:   update test_coll as m set m assign marray i in [20:39,0:19] values 5c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 003-aligned_tiling_2D_rpt-index.rasql.5:
test.sh:   update test_coll as m set m assign marray i in [0:39,0:39] values 6c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 003-aligned_tiling_2D_rpt-index.rasql.6:
test.sh:   update test_coll as m set m assign marray i in [20:39,0:39] values 7c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------

test.sh: running queries in 004-regular_tiling_3D_rpt-index.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 004-regular_tiling_3D_rpt-index.rasql.0:
test.sh:   insert into test_coll3 values marray i in [0:19,0:19,0:19] values 1c tiling regular [0:9,0:9,0:9] tile size 1000 index rpt_index
insert into test_coll3 values marray i in [0:19,0:19,0:19] values 1c tiling regular [0:9,0:9,0:9] tile size 1000 index rpt_index
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 004-regular_tiling_3D_rpt-index.rasql.1:
test.sh:   update test_coll3 as m set m assign marray i in [0:19,0:19,0:19] values 2c
update test_coll3 as m set m assign marray i in [0:19,0:19,0:19] values 2c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 004-regular_tiling_3D_rpt-index.rasql.2:
test.sh:   update test_coll3 as m set m assign marray i in [0:19,10:19,0:19] values 3c
update test_coll3 as m set m assign marray i in [0:19,10:19,0:19] values 3c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 004-regular_tiling_3D_rpt-index.rasql.3:
test.sh:   update test_coll3 as m set m assign marray i in [0:19,10:29,10:29] values 4c
update test_coll3 as m set m assign marray i in [0:19,10:29,10:29] values 4c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 004-regular_tiling_3D_rpt-index.rasql.4:
test.sh:   update test_coll3 as m set m assign marray i in [0:19,20:39,0:19] values 5c
update test_coll3 as m set m assign marray i in [0:19,20:39,0:19] values 5c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 004-regular_tiling_3D_rpt-index.rasql.5:
test.sh:   update test_coll3 as m set m assign marray i in [0:19,0:39,0:39] values 6c
update test_coll3 as m set m assign marray i in [0:19,0:39,0:39] values 6c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 004-regular_tiling_3D_rpt-index.rasql.6:
test.sh:   update test_coll3 as m set m assign marray i in [0:19,20:39,0:39] values 7c
update test_coll3 as m set m assign marray i in [0:19,20:39,0:39] values 7c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------

test.sh: running queries in 005-regular_tiling_3D_rpt-index_slices.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 005-regular_tiling_3D_rpt-index_slices.rasql.0:
test.sh:   insert into test_coll3 values marray i in [0:0,0:19,0:19] values 1c tiling regular [0:1,0:9,0:9] tile size 200 index rpt_index
insert into test_coll3 values marray i in [0:0,0:19,0:19] values 1c tiling regular [0:1,0:9,0:9] tile size 200 index rpt_index
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 005-regular_tiling_3D_rpt-index_slices.rasql.1:
test.sh:   update test_coll3 as m set m[2,0:19,0:19] assign marray i in [0:19,0:19] values 2c
update test_coll3 as m set m[2,0:19,0:19] assign marray i in [0:19,0:19] values 2c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 005-regular_tiling_3D_rpt-index_slices.rasql.2:
test.sh:   update test_coll3 as m set m[3,0:19,0:19] assign marray i in [0:19,0:19] values 3c
update test_coll3 as m set m[3,0:19,0:19] assign marray i in [0:19,0:19] values 3c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------

test.sh: running queries in 006-aligned_tiling_3D_rpt-index_slices.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 006-aligned_tiling_3D_rpt-index_slices.rasql.0:
test.sh:   insert into test_coll3 values marray i in [0:0,0:19,0:19] values 1c tiling aligned [0:1,0:9,0:9] tile size 200 index rpt_index
insert into test_coll3 values marray i in [0:0,0:19,0:19] values 1c tiling aligned [0:1,0:9,0:9] tile size 200 index rpt_index
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 006-aligned_tiling_3D_rpt-index_slices.rasql.1:
test.sh:   update test_coll3 as m set m[1,0:19,0:19] assign marray i in [0:19,0:19] values 2c
update test_coll3 as m set m[1,0:19,0:19] assign marray i in [0:19,0:19] values 2c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 006-aligned_tiling_3D_rpt-index_slices.rasql.2:
test.sh:   update test_coll3 as m set m[2,0:19,0:19] assign marray i in [0:19,0:19] values 3c
update test_coll3 as m set m[2,0:19,0:19] assign marray i in [0:19,0:19] values 3c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------
test.sh: 006-aligned_tiling_3D_rpt-index_slices.rasql.3:
test.sh:   update test_coll3 as m set m[3,0:19,0:19] assign marray i in [0:19,0:19] values 4c
update test_coll3 as m set m[3,0:19,0:19] assign marray i in [0:19,0:19] values 4c
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------

test.sh: running queries in 007-aoi_tiling_2D_default.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 007-aoi_tiling_2D_default.rasql.0:
test.sh:   insert into test_coll values marray i in [0:19,0:19] values 1c tiling area of interest [0:9,0:9]
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------

test.sh: running queries in 008-aoi_tiling_2D_subtiling.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 008-aoi_tiling_2D_subtiling.rasql.0:
test.sh:   insert into test_coll values marray i in [0:19,0:19] values 1c tiling area of interest [0:9,0:9] with subtiling
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------

test.sh: running queries in 009-aoi_tiling_2D_nolimit.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 009-aoi_tiling_2D_nolimit.rasql.0:
test.sh:   insert into test_coll values marray i in [0:19,0:19] values 1c tiling area of interest [0:9,0:9] with no_limit
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------

test.sh: running queries in 010-aoi_tiling_2D_regroup.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 010-aoi_tiling_2D_regroup.rasql.0:
test.sh:   insert into test_coll values marray i in [0:19,0:19] values 1c tiling area of interest [0:9,0:9] with regroup
test.sh: Result of query is correct.
test.sh: Result of query is correct.
----------------------------------------------------------------------

test.sh: running queries in 011-aoi_tiling_2D_regroupandsubtiling.rasql

test.sh: creating collection... ok.
test.sh: creating collection... ok.
----------------------------------------------------------------------
test.sh: 011-aoi_tiling_2D_regroupandsubtiling.rasql.0:
test.sh:   insert into test_coll values marray i in [0:19,0:19] values 1c tiling area of interest [0:9,0:9] with regroup_and_subtiling
test.sh: Result of query is correct.
test.sh: Result of query is correct.

test.sh: -------------------------------------------------------
test.sh: Test summary
test.sh: 
test.sh:   Test finished at: Tue Jul  1 13:17:11 CEST 2014
test.sh:   Total tests run : 72
test.sh:   Successful tests: 72
test.sh:   Failed tests    : 0
test.sh:   Skipped tests   : 0
test.sh:   Detail test log : /home/rasdaman/rasdaman/systemtest/testcases_mandatory/test_tiling/log
test.sh: -------------------------------------------------------


test.sh: testing rasdaman authentication at Tue Jul 1 13:17:11 CEST 2014
+++ good cases
+++ +++ write
+++ +++ read
+++ +++ write (2)
+++ +++ set up test env for subsequent cases
+++ good cases done.
+++ bad cases
+++ +++ nonex login
Recognized bad case, exit code 255
+++ +++ write op with r/o login
Recognized bad case, exit code 255
Recognized bad case, exit code 255
Recognized bad case, exit code 255
+++ +++ wrong passwd
Recognized bad case, exit code 255
Recognized bad case, exit code 255
+++ bad cases done.
+++ cleanup:
test.sh: done at Tue Jul 1 13:17:12 CEST 2014.


test.sh: starting test at Tue Jul  1 13:17:12 CEST 2014
test.sh: 
test.sh: test initialization...
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: running tests

----------------------------------------------------------------------
test.sh:  test query in general_array_condenser_max.rasql

bug is fixed
----------------------------------------------------------------------
test.sh:  test query in general_array_condenser_min.rasql

bug is fixed
----------------------------------------------------------------------
test.sh:  test query in induction_all_operations_==.rasql

bug is unfixed
----------------------------------------------------------------------
test.sh:  test query in scaling.rasql

bug is unfixed
----------------------------------------------------------------------
test.sh:  test query in struct_component_selection_3.rasql

bug is unfixed
----------------------------------------------------------------------
test.sh:  test query in the_array_bound_asterisk.rasql

bug is unfixed

test.sh: -------------------------------------------------------
test.sh: Test summary
test.sh: 
test.sh:   Test finished at: Tue Jul  1 13:17:15 CEST 2014
test.sh:   Total tests run : 6
test.sh:   Successful tests: 2
test.sh:   Failed tests    : 4
test.sh:   Skipped tests   : 0
test.sh:   Detail test log : /home/rasdaman/rasdaman/systemtest/testcases_open/test_select/log
test.sh: -------------------------------------------------------


test.sh: starting test at Tue Jul  1 13:17:15 CEST 2014
test.sh: 
test.sh: rgb already imported.
test.sh: mr already imported.
test.sh: eobstest already imported.
test.sh: mean_summer_airtemp already imported.
test.sh: mean_summer_airtemp_repeat already imported.
test.sh: float_4d already imported.
test.sh: double_1d already imported.
test.sh: irr_cube_1 already imported.
test.sh: irr_cube_2 already imported.
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: creating collection... ok.
test.sh: inserting data... ok.
test.sh: creating collection... ok.
test.sh: inserting data... ok.

running rasql test: 007-547_rgb_from_float.rasql.fixed
ticket URL: http://rasdaman.org/ticket/547

select encode((((float)((((((data).1)/(((((((((0.1)*((data).2)))+(((0.1)*((data).0)))))+(((0.4)*((data).2)))))+(((0.4)*((data).2)))))))-(1)))) * {1c,0c,0c} + ((float)(((((100)*((((((data).0)-((data).1)))/((((data).2)+((data).1)))))))*((((((data).0)-((data).1)))/((((data).0)+((data).2)))))))) * {0c,1c,0c} + ((float)(((((100)*((((((data).2)-((data).1)))/((((data).2)+((data).1)))))))*((((((data).1)-((data).2)))/((((data).1)+((data).2)))))))) * {0c,0c,1c}), "GTiff", "NODATA=65535;65535;65535;") from test_float AS data

test.sh: running pre-test script...
test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
test.sh: running post-test script...
running rasql test: 008-358_subset_doesnt_intersect_domain.rasql.fixed
ticket URL: http://rasdaman.org/ticket/358

select csv(c[7:7,-46:-46,150110:150113]) from eobstest AS c

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running rasql test: 009-326_insert_segfault.rasql
ticket URL: http://rasdaman.org/ticket/326

select csv(c) from test_insert as c

test.sh: running pre-test script...
test.sh: byte comparison
test.sh:  ->  TEST SKIPPED
--------------------------------------------------------------------------------------------
test.sh: running post-test script...
running rasql test: 010-648_composite_type_aggregation.rasql
ticket URL: http://rasdaman.org/ticket/648

select max_cells(c) from test_aggregate as c

test.sh: running pre-test script...
Using error text file: /home/rasdaman/install/share/rasdaman//errtxts
rasdl: rasdaman schema and database manipulation tool, rasdaman v9.0.3-gc9bdeb9 on base DBMS pgsql -- generated on 01.07.2014 13:01:23.
Reading rasdaman data definition file /tmp/types.dl...inserting symbols into database...ok
ok
rasdl done.

test.sh: byte comparison
test.sh:  ->  TEST SKIPPED
--------------------------------------------------------------------------------------------
test.sh: running post-test script...
--------------------------------------------------------


test.sh: -------------------------------------------------------
test.sh: Test summary
test.sh: 
test.sh:   Test finished at: Tue Jul  1 13:17:25 CEST 2014
test.sh:   Total tests run : 4
test.sh:   Successful tests: 2
test.sh:   Failed tests    : 0
test.sh:   Skipped tests   : 2
test.sh:   Detail test log : /home/rasdaman/rasdaman/systemtest/testcases_open/test_tickets/log
test.sh: -------------------------------------------------------


test.sh: starting test at Tue Jul  1 13:17:26 CEST 2014
test.sh: 
test.sh: memleak test pass


test.sh: starting test at Tue Jul  1 13:17:26 CEST 2014
test.sh: 
test.sh: Testing service: secore

running test: 01-single_crs.kvp

/crs?authority=EPSG&version=0&code=4327

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/01-single_crs.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 01-single_crs.rest

/crs/EPSG/0/4327

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/01-single_crs.rest.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 02-single_crs_unordered_keys.kvp

/crs?authority=EPSG&code=4327&version=0

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/02-single_crs_unordered_keys.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 03-single_crs_missing_authority.error.kvp

/crs?version=0&code=4327

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 04-single_crs_missing_version.error.kvp

/crs?authority=EPSG&code=4327

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 05-crs_directory.kvp

/crs?authority=OGC&version=0

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/05-crs_directory.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST FAILED
--------------------------------------------------------------------------------------------
running test: 05-crs_directory.rest

/crs/OGC/0

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/05-crs_directory.rest.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST FAILED
--------------------------------------------------------------------------------------------
running test: 06-single_crs_misspelled_key.error.kvp

/crs?authority=EPSG&version=0&c0d3=4327

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 07-single_crs_case_insensitive_keys.kvp

/crs?AUTHORITY=EPSG&version=0&cOdE=4327

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/07-single_crs_case_insensitive_keys.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 08-single_crs_case_sensitive_values.error.kvp

/crs?authority=epsg&version=0&code=4327

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 08-single_crs_case_sensitive_values.error.rest

/crs/epsg/0/4327

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 09-single_crs_illegal_optional_parameter.error.kvp

/crs?authority=EPSG&version=0&code=4327&foo=qwerty

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 09-single_crs_illegal_optional_parameter.error.rest

/crs/EPSG/0/4327?foo=qwerty

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 10-crs_equality.kvp

/equal?
  1=%SECORE_URL%%2Fcrs%2FEPSG%2F0%2F4327&
  2=%SECORE_URL%%2Fcrs?authority%3DEPSG%26version%3D0%26code%3D4327

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/10-crs_equality.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 11-crs_inequality.kvp

/equal?
  1=%SECORE_URL%%2Fcrs?authority%3DEPSG%26code%3D4326%26version%3D0&
  2=%SECORE_URL%%2Fcrs?authority%3DEPSG%26version%3D0%26code%3D4327

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/11-crs_inequality.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 12-compound_crs.kvp

/crs-compound?
  1=%SECORE_URL%%2Fcrs%2FEPSG%2F0%2F4327&
  2=%SECORE_URL%%2Fcrs?authority%3DEPSG%26version%3D0%26code%3D5715

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/12-compound_crs.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 13-compound_crs_wrong_index.error.kvp

/crs-compound?
  3=%SECORE_URL%%2Fcrs%2FEPSG%2F0%2F4327&
  2=%SECORE_URL%%2Fcrs?authority%3DEPSG%26version%3D0%26code%3D5715

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 14-compound_crs_with_compound_crs.error.kvp

/crs-compound?
  1=%SECORE_URL%%2Fcrs%2FEPSG%2F0%2F4327&
  2=%SECORE_URL%%2Fcrs-compound%3F1%3D%SECORE_URL%%2Fcrs%2FEPSG%2F0%2F4327%262%3D%SECORE_URL%%2Fcrs%2FEPSG%2F0%2F5715

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 15-parametrized_crs.kvp

/crs?authority=AUTO&version=1.3&code=42001&lon=10

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/15-parametrized_crs.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 15-parametrized_crs.rest

/crs/AUTO/1.3/42001?lon=10

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/15-parametrized_crs.rest.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 16-parametrized_crs_illegal_parameter.error.kvp

/crs/AUTO/1.3/42001?foo=10

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 16-parametrized_crs_illegal_parameter.error.rest

/crs?authority=AUTO&version=1.3&code=42001&foo=10

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 17-compound_crs_with_parametrized_crs.kvp

/crs-compound?
  1=%SECORE_URL%%2Fcrs?authority%3DAUTO%26version%3D1.3%26code%3D42001%26lon%3D10&
  2=%SECORE_URL%%2Fcrs?authority%3DEPSG%26version%3D0%26code%3D5715

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/output/17-compound_crs_with_parametrized_crs.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 18-invalid_code_t559.error.rest

/crs/EPSG/0/432

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------

test.sh: -------------------------------------------------------
test.sh: Test summary
test.sh: 
test.sh:   Test finished at: Tue Jul  1 13:17:52 CEST 2014
test.sh:   Total tests run : 24
test.sh:   Successful tests: 22
test.sh:   Failed tests    : 2
test.sh:   Skipped tests   : 0
test.sh:   Detail test log : /home/rasdaman/rasdaman/systemtest/testcases_services/test_secore/log
test.sh: -------------------------------------------------------


Old logfile found, copying it to /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcps/log.save
test.sh: starting test at Tue Jul  1 13:17:52 CEST 2014
test.sh: 
test.sh: Testing service: wcps
test.sh: rgb already imported.
test.sh: mr already imported.
test.sh: eobstest already imported.
test.sh: mean_summer_airtemp already imported.
test.sh: mean_summer_airtemp_repeat already imported.
test.sh: float_4d already imported.
test.sh: double_1d already imported.
test.sh: irr_cube_1 already imported.
test.sh: irr_cube_2 already imported.

running test: 01-just_trim.test

for c in ( rgb ) return encode( c[ i(0:100), j(0:100) ], "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 02-trim_field_difference.test

for c in ( rgb ) return encode( ((char) abs( c.1 - c.0 ))[ i(0:250), j(0:200) ], "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 03-simple_count.test

for c in ( rgb ) return count( c.1 = 0 )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 04-vegetation_index.test

for c in ( rgb ) return encode((char) ( ((c.0 / ((float)c.0 + c.1))-(c.1 / ((float)c.0 + c.1))) > 0.6 ) * 255, "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 05-just_encode.test

for c in ( rgb ) return encode( c, "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 06-just_cast_inverse.test

for c in ( rgb ) return encode( ((char)255 - c.red)[i(50:150),j(50:150)], "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 07-just_slice.test

for m in ( mr ) return encode( slice( m, {i(10)} ), "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 08-just_encode_field.test

for m in ( rgb ) return encode( m.red, "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 09-just_log.test

for s in ( rgb ) return encode( log((s.2)[ i(100:200), j(100:200) ] ), "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 100-trim_crs1_wrong_order.error.test

for c in ( eobstest ) return encode( c[ Long:"CRS:1"(226:138) ], "csv")

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 101-max_delta_px_history.test

for c in (irr_cube_2) return encode (
   coverage max_delta_pixel_history
   over     $t t ( 1 : 3 )
   values   max((c[E(100000:110000), N(5100000:5110000), ansi:"CRS:1"($t)]).b1 -
                (c[E(100000:110000), N(5100000:5110000), ansi:"CRS:1"($t - 1)]).b2)
, "csv")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 102-scaled_irr_series.test

for c in (irr_cube_2) return encode (
   scale( slice( (c[ansi("2008-01-01T00Z":"2008-01-01T12Z")]).b2, ansi:"CRS:1"(0)),
          { N:"CRS:1"(0:1), E:"CRS:1"(0:2) } )
, "csv")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 103-slice_scale_gridcov.test

for c in (float_4d)
return encode(
  scale(c[i(0),j(0)], { k(0:10), m(0:1) }),
"csv")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 104-scale_slice_ticket773.test

for c in (eobstest)
return encode(
  scale(         c[t("1950-01-01"), Long(43:44), Lat(24:24)],
  imageCrsDomain(c[t("1950-01-01"), Long(43:44), Lat(24:24)])),
"csv")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 10-just_field_difference.test

for s in ( rgb ) return encode( s.0 - s.1, "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 11_vegetation_index_computation.test

for s in ( rgb ) return encode((char) (s.0 - s.1)/(s.0 + s.1), "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 12-vegetation_index.test

for s in ( rgb ) return encode( ((s.0-s.1)/(s.0+s.1)) > 0.1, "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 13-just_encode_three_coverages.test

for s in ( rgb, rgb, rgb ) return encode( s[ i(0:100), j(0:100) ], "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 14_count_vegetation_cells.test

for s in ( rgb, rgb, rgb ) return       
        count( (s.0+s.1)/(s.0-s.1) >= 0)
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 15-construct_simple_gray_gradient.test

for c in ( rgb ) 
return encode( 
        (char) 
        coverage greyImage 
        over $first x(51:150), 
             $second y(0:99) 
        values $first
, "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 16-simple_histogram.test

for c in ( mr ) 
return  encode( 
        coverage histogram 
        over $n x(0:255) 
        values count( c = $n )
, "csv" )
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 17-climate_over_earth.test

for clouds in ( mr ), 
        mask   in ( mr ) 
return encode( 
        (char) clouds[ i(0) ] * mask[ i(0) ]
, "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 18-climate_over_water.test

for clouds in ( mr), 
        mask in ( mr) 
return encode( 
        (char) clouds[ i(0) ] * (mask[ i(0) ] = 0)
, "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 19-just_sinus.test

for c in (rgb) return encode(sin((c.1)[ i(100:200), j(100:200) ]), "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 20-just_tangent.test

for c in (rgb) return encode(tan((c.1)[ i(100:200), j(100:200) ]), "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 21-just_exponent.test

for c in (rgb) return encode(exp((c.1)[ i(100:200), j(100:200) ]/100), "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 22-just_max_double.test

for c in ( rgb ) return max((double)c.2)

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 23_shown_only_green_areas.test

for r in (rgb)
return  encode(
            r * ((r.green > 130) and (r.red < 110) and (r.blue < 140))
        , "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 24-condense_coverage_one_var.test

for a in (rgb) return
    condense +
    over $x x(1:10)
    using $x * (a[i($x), j(10)]).red

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 25-condense_field_two_vars.test

for a in (rgb) return
    condense +
        over $kx x (1:10),
             $ky y (25:75)
        using $kx * (a[i($kx),j($ky)]).red

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 26-constant_coverage.test

for c in (rgb) return 
encode(
        coverage const 
        over $px x(0:1) 
        value list <0;1>
, "csv")
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 27-construct_boring_histogram.test

for c in ( mr )
return
encode( coverage histogram
        over     $n x(0:20)
        values   condense +
                        over     $px x(0:20),
                                 $py y(0:20)
                        using    1,
        "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 28-construct_histogram_range_condition.test

for c in ( mr )
return
encode( coverage histogram
        over     $n x(-20:20)
        values   condense +
                        over     $px x(10:20),
                                 $py y(10:20)
                        using    c[ i($px), j($py) ]>$n - 1 and c[ i($px), j($py) ]<=$n,
        "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 29-filter_image(lines).test

for c in (rgb) return encode((char)
                coverage filteredImage
                over $px x(10:240),
                     $py y(10:230)
                values
                        condense +
                        over $kx x(-1:1),
                             $ky y(-1:1)
                        using
                                (coverage kernel
                                over $x x (-1:1),
                                     $y y(-1:1)
                                value list < 1; 1; 1; 0; 0; 0; -1; -1; -1 >
                                )[x($kx),y($ky)]
                                        *
                                (c[i($px+$kx),j($py+$ky)]).red
        , "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 30-construct_count.test

for c in ( mr )
return  encode(
          coverage histogram
          over $n x(0:2)
          values count( c = $n )
      , "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 31-Discrete_Fourier.test

for c in (rgb) return 
encode( 

        coverage DFT
        over $xx x(65:70),
             $xy y(65:70)
        values
                condense + 
                over $ux x(65:70),
                     $uy y(65:70)
                using
                        c[i($ux),j($uy)]
                        *
                        cos(
                                ( -2 * (22.0/7.0) )
                                *
                                (
                                        ( (double) ($ux*$xx) / (70 - 65  + 1) )
                                        +
                                        ( (double) ($uy*$xy) / (70 - 65 + 1 ) )
                                )
                        )
, "png", "nodata=0")

test.sh: image comparison
/home/rasdaman/rasdaman/systemtest/testcases_services/test_wcps/output/temporary_out /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcps/output/temporary_oracle differ: byte 298, line 4
test.sh:  -> TEST SKIPPED
--------------------------------------------------------------------------------------------
running test: 32-construct_condense_cosinus_gray_image.test

 for c in (mr) return encode((char)
       coverage DFT
       over $px x(0:10),
            $py y(0:10)
       values
           condense +
           over $kx x(0:10),
                $ky y(0:10)
           using cos(0.6)   , "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 33-construct_condense_gray_image.test

for c in (mr) return encode((char)
       coverage gray_image
       over $px x(0:10),
            $py y(0:10)
       values
           condense +
           over $kx x(0:10),
                $ky y(0:10)
           using 1   , "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 34-where_clause.test

for c in (mr)
where avg(c)>30
return
encode (c, "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 35-coordinates_in_wgs84_crs.test

for c in (mr) return encode(c [i:"CRS:1" (1:100), j:"CRS:1" (1:100) ], "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 36-simple_overlay.test

for c in (rgb) return encode(c[ i(0:100), j(0:100) ] overlay (char)(c[ i(0:100), j(0:100) ] * 3), "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 37-simple_extend.test

for c in (rgb) return encode(extend(c, i(0:500), j(0:500) ), "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 38-complex_extend.test

for t in (rgb) return encode(extend( (t + (char)50),  i :"CRS:1" ( 0:500 ),  j: "CRS:1" (0: 500)  ), "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 39-complex_extend-2.test

for t in (mr) return encode(extend( t,  i :"CRS:1" ( 0:500 ),  j: "CRS:1" (0: 500)  ) + (char) 0 , "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 40-range_structure.test

for c in ( rgb ) return
encode(
    c.red *
     {
        red: (char) 1;
        green: (char) 2;
        blue: (char) 3
     },
"png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 41-filter_calculation_reloaded.test

for c in (mr) return
encode((char)
  coverage filteredImage
    over $px x(1:100),
         $py y(1:100)
    values
        sqrt(abs(
          condense +
          over $kx x(-1:1),
               $ky y(-1:1)
          using
               ((((double)coverage kernel
                          over $x x(-1:1),
                               $y y(-1:1)
                          value list < -1; 0; 1; -2; 0; 2;-1; 0; 1 >)[x($kx),y($ky)])
                                      *(c[i($px+$kx),j($py+$ky)])/(8*5.13712275))
            ))
, "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 42-filter_calculation.test

for c in (mr) return encode((char)
  coverage filteredImage
    over $px x(1:100),
              $py y(1:100)
    values
                  (
                    condense +
                          over $kx x(-1:1),
                                 $ky y(-1:1)
                          using
                               ((((double)coverage kernel
                                                    over $x x (-1:1),
                                                           $y y(-1:1)
                                                     value list < -1; 0; 1; -2; 0; 2;-1; 0; 1 >) [x($kx),y($ky)])
                                                               *(c[i($px+$kx),j($py+$ky)])/(8*5.13712275))
                     )
, "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 43-encoder_options.test

for a in (mr) return
    encode(a[ i(0:100), j(0:100) ],"dem", "startx=0,starty=0,endx=100,endy=100,resx=0.1,resy=0.15")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 44-scaling_operation.test

for c in (rgb)
    return encode(scale(c, { i(1:100), j(1:100) }), "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 45-scaling_operation_mr.test

for c in (mr) return encode(
    scale(
        trim(c, { i (120:130), j (50:60) }),
        { i (0:100), j (0:100) }, { }),
"png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 46-mix_scale_trim.test

for c in ( mr )
return
encode( c[i(100),j(50:60)] , "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 47-get-metadata-identifier.test

for c in ( mr )
return
identifier(c)
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 48-slice_scale.test

for c in ( eobstest )
return
encode( scale( c[t(2)], { Long:"CRS:1"(0:20), Lat:"CRS:1"(0:20) } ) , "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 49-range_structure_4_bands.test

for c in ( rgb )
return
encode(
{
  red:   c.red;
  green: c.green;
  blue:  c.blue;
  alpha: c.blue
}, "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 50-arithmetic_operation_ticket227.test

for c in (mr) return
   encode(
      count(trim(c, {i(100:101),j(100:101)}) > 0) * 2,
   "csv")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 51-mixed_case_reduce.test

for c in (mr) return AvG(c)

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 52-gtiff-params-filling.test

for c in (eobstest) return encode(
  c[
    t(1),
    Long:"http://www.opengis.net/def/crs/EPSG/0/4326" (20:35),
    Lat:"http://www.opengis.net/def/crs/EPSG/0/4326" (10:15)]),
"tiff", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 53-jpeg2000-params-filling.test

for c in (eobstest) return encode(
  c[
    t(1),
    Long:"http://www.opengis.net/def/crs/EPSG/0/4326" (20:35),
    Lat:"http://www.opengis.net/def/crs/EPSG/0/4326" (10:15)]),
"jpeg2000", "nodata=0")

test.sh: byte comparison
test.sh:  ->  TEST FAILED
--------------------------------------------------------------------------------------------
running test: 54-simple_extend_cbrace.test

for c in (rgb) return encode(extend(c, {i(0:500), j(0:500)} ), "png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 55-complex_extend_cbrace.test

for t in (rgb) return encode(extend( (t + (char)50),  {i :"CRS:1" ( 0:500 ),  j: "CRS:1" (0: 500)}  ), "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 56-complex_extend-2_cbrace.test

for t in (mr) return encode(extend( t,  {i :"CRS:1" ( 0:500 ),  j: "CRS:1" (0: 500)  ) + (char) 0 }, "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 57-coverage_constructor_t355.test

for c in (eobstest)
  return
    encode(
      coverage temp
        over
        $pt t(0:1)
      values (count(c[t($pt)]=30)) / (count(c[t($pt)]!=0)) * 100,
      "csv")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 58-overlay_performance_t349.test

for c in (mr)
return encode(
  (char)(({
    red:   ((char)((c < 20) * 200));
    green: ((char)((c < 20) * 10));
    blue:  ((char)((c < 20) * 10))
  }
overlay
  (char){
    red:   ((char)((c >= 20 and c < 25) * 255));
    green: ((char)((c >= 20 and c < 25) * 165));
    blue:  ((char)((c >= 20 and c < 25) * 0))
  }
overlay
  (char){
    red:   ((char)((c >= 25 and c < 30) * 255));
    green: ((char)((c >= 25 and c < 30) * 215));
    blue:  ((char)((c >= 25 and c < 30) * 0))
  }
overlay
  (char){
    red:   ((char)((c >= 30 and c < 35) * 255));
    green: ((char)((c >= 30 and c < 35) * 255));
    blue:  ((char)((c >= 30 and c < 35) * 0))
  }
overlay
  (char){
    red:   ((char)((c >= 35 and c < 40) * 173));
    green: ((char)((c >= 35 and c < 40) * 255));
    blue:  ((char)((c >= 35 and c < 40) * 47))
  }
overlay
  (char){
    red:   ((char)((c >= 40 and c < 45) * 20));
    green: ((char)((c >= 40 and c < 45) * 255));
    blue:  ((char)((c >= 40 and c < 45) * 20))
  }
overlay
  (char){
    red:   ((char)((c >= 45 and c < 50) * 10));
    green: ((char)((c >= 45 and c < 50) * 200));
    blue:  ((char)((c >= 45 and c < 50) * 10))
  }
overlay
  (char){
    red:   ((char)((c >= 50 and c < 55) * 0));
    green: ((char)((c >= 50 and c < 55) * 136));
    blue:  ((char)((c >= 50 and c < 55) * 0))
  }
overlay
  (char){
    red:   ((char)((c >= 55 and c < 253) * 0));
    green: ((char)((c >= 55 and c < 253) * 0));
    blue:  ((char)((c >= 55 and c < 253) * 255))
  }
overlay
  (char){
    red:   ((char)((c = 253) * 0));
    green: ((char)((c = 253) * 0));
    blue:  ((char)((c = 253) * 250))
  }
overlay
  (char){
    red:   ((char)((c = 254) * 255));
    green: ((char)((c = 254) * 235));
    blue:  ((char)((c = 254) * 190))
  }
overlay
  (char){
    red:   ((char)(c = 255) * 80);
    green: ((char)(c = 255) * 80);
    blue:  ((char)(c = 255) * 80)
  }
 
)[i(10:20),j(37:40)])
,
"png", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 59-sqrt_big_query.test

for c in (eobstest)
return sqrt(
(
(
  add(
    coverage averagesOverTime
    over     $T t(0:2)
    values
    (
      (((1/(count((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T + 1)]) <= 250)) * add(((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T + 1)]) * ((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T + 1)]) <= 250))) )) * 0.004 - 0.08)
      -
      avg(coverage averagesOverTime2
       over $T2 t(0:2)
       values(((1/(count((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T2 + 1)]) <= 250)) * add(((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T2 + 1)]) * ((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T2 + 1)]) <= 250))) )) * 0.004 - 0.08))
    )
    *
    (
      (((1/(count((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T + 1)]) <= 250)) * add(((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T + 1)]) * ((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T + 1)]) <= 250))) )) * 0.004 - 0.08)
      -
      avg(coverage averagesOverTime3
            over $T3 t(0:2)
            values(((1/(count((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T3 + 1)]) <= 250)) * add(((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T3 + 1)]) * ((c[Long:"CRS:1"(15:20),Lat:"CRS:1"(0:5),t(1 * $T3 + 1)]) <= 250))) )) * 0.004 - 0.08)
      )
    )
  )
)) / 15)

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 60-boolean_scalar_expr-t372.test

for c in (mr)
   return (max(c[i(100:100),j(100:100)]) = 1)

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 61-general_condense_where-t371.test

for c in (mr)
  return condense +
  over $x x(0:100),
       $y y(0:100)
  where (max(c[i($x:$x),j($y:$y)]) < 100)
  using c[i($x),j($y)]


test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 73-get_metadata_crsset_t422.test

for c in (mean_summer_airtemp) return crsSet(c)
test.sh: custom script
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 74-switch_scalar.test

for c in mr return encode(switch case c>20 return (char)2 case c>10 return (char)1 default return (char)0,"csv")
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 75-switch_array.test

for c in mr return encode(switch case c>0 return c default return (char)0,"csv")
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 76-switch_log.test

for c in mr return encode(switch case c>0 return log(c) default return (char)0,"csv")
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 77-pow_operation_int.test

for c in (mr) return encode( pow( c[i(100:110),j(100:110)], 2 ), "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 78-pow_operation_float.test

for c in (mr) return encode( pow( c[i(100:110),j(100:110)], 1.85 ), "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 79-range_on_t_axis-t335.test

for c in (eobstest)
return encode(
  coverage averagesOverTime
  over $T t(0:2)
  values ( avg(c[t($T:$T + 1)] ) ),
"csv")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 80-match_scale.test

for c in ( mr ), c2 in (rgb)
return
avg( scale( c, imageCrsDomain(c2) ) )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 81-gtiff_extend.test

for t in (eobstest) return encode(extend( t[t(1)],  { Long(-45:90),  Lat(5:80) }, "tiff", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 82-timestamp_in_subset.test

for c in (eobstest) return encode(
  c[
    t("1950-01-02"),
    Long(20:35),
    Lat(10:15)]),
"tiff", "nodata=0")

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 83-match_scale_3d.test

for c in ( mr ), d in (eobstest)
return avg(scale( c[i(120:150),j(120:150)], imageCrsDomain(d[t(0),Long:"CRS:1"(10:20),Lat:"CRS:1"(10:20)]) ))

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 84-minmax.test

for c in (mean_summer_airtemp)
  return 
        (condense min
        over     $py y (300:301)
        using    c[Long:"CRS:1"(100), Lat:"CRS:1"($py)])
        +
        (condense max
        over     $py y (300:301)
        using    c[Long:"CRS:1"(100), Lat:"CRS:1"($py)])

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 85-multiband_aggregation_t376.test

for c in (rgb)
return
  avg(c[i(100:102),j(100:102)])

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 86-get_metadata_domain.test

for c in (eobstest) return domain(c, Long, "http://www.opengis.net/def/crs/EPSG/0/4326")

test.sh: byte comparison
test.sh:  -> TEST SKIPPED
--------------------------------------------------------------------------------------------
running test: 87-get_metadata_imagecrs.test

for c in (eobstest) return imageCrs(c)

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 88-get_metadata_imagecrsdomain.test

for c in (eobstest) return imageCrsDomain(c, Lat)

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 89-cov_construct_imagecrsdomain.test

for c in (eobstest)
return encode(
  (coverage newcov
  over $px x(imageCrsDomain(c[Lat(25:35)], Lat)),
       $pt t(imageCrsDomain(c, t))
  values avg(c[Lat($px),t($pt)])
  )
, "csv")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 90-get_metadata_domain.error.test

for c in (eobstest) return domain(c, Long, "http://www.opengis.net/def/crs/EPSG/0/32633")

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 91-get_metadata_domain2.test

for c in (eobstest) return domain(c, Long, "CRS:1")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 92-scaling_operation_swap_axes.test

for c in (mr) return encode(scale(c, { j:"CRS:1"(0:4), i:"CRS:1"(0:2)}), "csv")

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 93-just_trim_asterisk.test

for c in ( rgb ) return encode( c[ i(*:1), j(340:*) ], "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 94-just_trim_asterisk2.test

for c in ( mr ) return encode( c[ i(*:*), j(0) ], "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 95-just_slice_asterisk.error.test

for c in (mr) return max(c[j(*)])

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 96-scalar_boolean_t407.test

for c in ( mr ) return encode((char)(1 * (c[i(160:180),j(100:130)] > 150) + (c[i(160:180),j(100:130)] <= 150) * 100), "png", "nodata=0" )

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 97-trim_asterisk_time1.test

for c in ( eobstest ) return encode( c[ Long(69.6), Lat(30.05), t("1950-01-03T13-0500":*) ], "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 98-trim_asterisk_time2.test

for c in ( eobstest ) return encode( c[ Long(69.6), Lat(30.05), t(*:"1950-01-03T13-0500") ], "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 99-trim_asterisk_time3.test

for c in ( eobstest ) return encode( c[ Long(69.6), Lat(30.05), t(*:*) ], "csv" )

test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------

test.sh: -------------------------------------------------------
test.sh: Test summary
test.sh: 
test.sh:   Test finished at: Tue Jul  1 13:19:25 CEST 2014
test.sh:   Total tests run : 93
test.sh:   Successful tests: 90
test.sh:   Failed tests    : 1
test.sh:   Skipped tests   : 2
test.sh:   Detail test log : /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcps/log
test.sh: -------------------------------------------------------


Old logfile found, copying it to /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/log.save
test.sh: starting test at Tue Jul  1 13:19:25 CEST 2014
test.sh: 
test.sh: Testing service: wcs
test.sh: rgb already imported.
test.sh: mr already imported.
test.sh: eobstest already imported.
test.sh: mean_summer_airtemp already imported.
test.sh: mean_summer_airtemp_repeat already imported.
test.sh: float_4d already imported.
test.sh: double_1d already imported.
test.sh: irr_cube_1 already imported.
test.sh: irr_cube_2 already imported.

running test: 01-get_capabilities.kvp

service=WCS&
version=2.0.1&
request=GetCapabilities

test.sh: custom script
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 01-get_capabilities.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCapabilities
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
</wcs:GetCapabilities>

test.sh: custom script
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 02-describe_coverage.kvp

service=WCS&
version=2.0.1&
request=DescribeCoverage&
coverageId=mr

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/02-describe_coverage.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 02-describe_coverage.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:DescribeCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
</wcs:DescribeCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/02-describe_coverage.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 03-get_coverage.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/03-get_coverage.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 03-get_coverage.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/03-get_coverage.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 04-get_coverage_tiff.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
format=image/tiff

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 04-get_coverage_tiff.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <gml:format>image/tiff</gml:format>
</wcs:GetCoverage>

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 05-get_coverage_subset.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
subset=i(10,20)&
subset=j(10,20)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/05-get_coverage_subset.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 05-get_coverage_subset.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>i</wcs:Dimension>
    <wcs:TrimLow>10</wcs:TrimLow>
    <wcs:TrimHigh>20</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:TrimLow>10</wcs:TrimLow>
    <wcs:TrimHigh>20</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/05-get_coverage_subset.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 06-get_coverage_slice.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Long(30)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/06-get_coverage_slice.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 06-get_coverage_slice.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:SlicePoint>30</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/06-get_coverage_slice.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 07-get_coverage_slice2.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Long(30)&
subset=Lat(30)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/07-get_coverage_slice2.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 07-get_coverage_slice2.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:SlicePoint>30</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:SlicePoint>30</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/07-get_coverage_slice2.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 08-get_coverage_jp2.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
format=image/jp2

test.sh: byte comparison
test.sh:  ->  TEST FAILED
--------------------------------------------------------------------------------------------
running test: 08-get_coverage_jp2.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <gml:format>image/jp2</gml:format>
</wcs:GetCoverage>

test.sh: byte comparison
test.sh:  ->  TEST FAILED
--------------------------------------------------------------------------------------------
running test: 09-get_coverage_scale1.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
scalefactor=2.0

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/09-get_coverage_scale1.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 09-get_coverage_scale1.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:Extension>
    <scal:Scaling>
      <scal:ScaleByFactor>
        <scal:scaleFactor>2.0</scal:scaleFactor>
      </scal:ScaleByFactor>
    </scal:Scaling>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/09-get_coverage_scale1.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 10-get_coverage_scale2.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
scaleaxes=i(0.5)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/10-get_coverage_scale2.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 10-get_coverage_scale2.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:Extension>
    <scal:Scaling>
      <scal:ScaleAxesByFactor>
        <scal:ScaleAxis>
          <scal:axis>i</scal:axis>
          <scal:scaleFactor>0.5</scal:scaleFactor>
        </scal:ScaleAxis>
      </scal:ScaleAxesByFactor>
    </scal:Scaling>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/10-get_coverage_scale2.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 11-get_coverage_scale3.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
scalesize=j(16)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/11-get_coverage_scale3.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 11-get_coverage_scale3.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:Extension>
    <scal:Scaling>
      <scal:ScaleToSize>
        <scal:TargetAxisSize>
          <scal:axis>j</scal:axis>
          <scal:targetSize>16</scal:targetSize>
        </scal:TargetAxisSize>
      </scal:ScaleToSize>
    </scal:Scaling>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/11-get_coverage_scale3.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 12-get_coverage_scale4.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
scaleextent=j(16:34)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/12-get_coverage_scale4.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 12-get_coverage_scale4.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:Extension>
    <scal:Scaling>
      <scal:ScaleToExtent>
        <scal:TargetAxisExtent>
          <scal:axis>j</scal:axis>
          <scal:low>16</scal:low>
          <scal:high>34</scal:high>
        </scal:TargetAxisExtent>
      </scal:ScaleToExtent>
    </scal:Scaling>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/12-get_coverage_scale4.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 13-get_coverage_tiff_slice.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Long(50)&
format=image/tiff

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 13-get_coverage_tiff_slice.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:SlicePoint>50</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <gml:format>image/tiff</gml:format>
</wcs:GetCoverage>

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 14-get_coverage_jp2_slice_t_crs1.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=t,CRS:1(1)&
format=image/jp2

test.sh: byte comparison
test.sh:  ->  TEST FAILED
--------------------------------------------------------------------------------------------
running test: 14-get_coverage_jp2_slice_t_crs1.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>t</wcs:Dimension>
    <!-- Problem: inconsistent CRS handling KVP/WCS : OGC12-167 change request #257 (Andrea Aime) -->
    <wcs:SlicePoint>1</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <gml:format>image/jp2</gml:format>
</wcs:GetCoverage>

test.sh: byte comparison
test.sh:  ->  TEST FAILED
--------------------------------------------------------------------------------------------
running test: 15-get_coverage_rangeSubsetting1.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=rgb&
rangesubset=red:green

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/15-get_coverage_rangeSubsetting1.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 15-get_coverage_rangeSubsetting1.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:rsub="http://www.opengis.net/wcs/range-subsetting/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>rgb</wcs:CoverageId>
  <wcs:Extension>
    <rsub:rangeSubset>
      <rsub:rangeItem>
        <rsub:rangeInterval>
          <rsub:startComponent>red</rsub:startComponent>
          <rsub:endComponent>green</rsub:endComponent>
        </rsub:rangeInterval>
      </rsub:rangeItem>
    </rsub:rangeSubset>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/15-get_coverage_rangeSubsetting1.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 16-get_coverage_rangeSubsetting2.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=rgb&
rangesubset=green

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/16-get_coverage_rangeSubsetting2.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 16-get_coverage_rangeSubsetting2.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:rsub="http://www.opengis.net/wcs/range-subsetting/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>rgb</wcs:CoverageId>
  <wcs:Extension>
    <rsub:rangeSubset>
      <rsub:rangeItem>
        <rsub:rangeComponent>green</rsub:rangeComponent>
      </rsub:rangeItem>
    </rsub:rangeSubset>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/16-get_coverage_rangeSubsetting2.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 17-get_coverage_rangeSubsetting3.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=rgb&
rangesubset=green,red

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/17-get_coverage_rangeSubsetting3.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 17-get_coverage_rangeSubsetting3.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:rsub="http://www.opengis.net/wcs/range-subsetting/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>rgb</wcs:CoverageId>
  <wcs:Extension>
    <rsub:rangeSubset>
      <rsub:rangeItem>
        <rsub:rangeComponent>green</rsub:rangeComponent>
      </rsub:rangeItem>
      <rsub:rangeItem>
        <rsub:rangeComponent>red</rsub:rangeComponent>
      </rsub:rangeItem>
    </rsub:rangeSubset>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/17-get_coverage_rangeSubsetting3.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 18-get_coverage_0D.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
subset=i(25)&
subset=j(0)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/18-get_coverage_0D.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 18-get_coverage_0D.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>i</wcs:Dimension>
    <wcs:SlicePoint>25</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:SlicePoint>0</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/18-get_coverage_0D.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 19-get_coverage_trim_irregular_axis.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_1&
subset=i(0,2)&
subset=j(3,5)&
subset=k(3,8)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/19-get_coverage_trim_irregular_axis.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 19-get_coverage_trim_irregular_axis.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_1</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>i</wcs:Dimension>
    <wcs:TrimLow>0</wcs:TrimLow>
    <wcs:TrimHigh>2</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:TrimLow>3</wcs:TrimLow>
    <wcs:TrimHigh>5</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>k</wcs:Dimension>
    <wcs:TrimLow>3</wcs:TrimLow>
    <wcs:TrimHigh>8</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/19-get_coverage_trim_irregular_axis.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 20-get_coverage_slice_irregular_axis.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_1&
subset=i(0,2)&
subset=j(3,5)&
subset=k(5)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/20-get_coverage_slice_irregular_axis.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 20-get_coverage_slice_irregular_axis.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_1</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>i</wcs:Dimension>
    <wcs:TrimLow>0</wcs:TrimLow>
    <wcs:TrimHigh>2</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:TrimLow>3</wcs:TrimLow>
    <wcs:TrimHigh>5</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionSlice>
    <wcs:Dimension>k</wcs:Dimension>
    <wcs:SlicePoint>5</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/20-get_coverage_slice_irregular_axis.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 21-get_coverage_jp2_irregular_axis.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_1&
subset=j(5)&
format=image/jp2

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 21-get_coverage_jp2_irregular_axis.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:SlicePoint>5</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <gml:format>image/jp2</gml:format>
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 22-get_coverage_tiff_irregular_axis.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_1&
subset=j(5)&
format=image/tiff

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 22-get_coverage_tiff_irregular_axis.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:SlicePoint>5</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <gml:format>image/tiff</gml:format>
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 27-get_coverage_slice_time.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Lat(30,31)&
subset=Long(30,35)&
subset=t("1950-01-01")

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/27-get_coverage_slice_time.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 27-get_coverage_slice_time.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:TrimLow>30</wcs:TrimLow>
    <wcs:TrimHigh>31</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:TrimLow>30</wcs:TrimLow>
    <wcs:TrimHigh>35</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionSlice>
    <wcs:Dimension>t</wcs:Dimension>
    <wcs:SlicePoint>"1950-01-01"</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/27-get_coverage_slice_time.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 28-get_coverage_trim_time.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Lat(31)&
subset=Long(30)&
subset=t("1950-01-01","1950-01-05")

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/28-get_coverage_trim_time.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 28-get_coverage_trim_time.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:SlicePoint>31</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:SlicePoint>30</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionTrim>
    <wcs:Dimension>t</wcs:Dimension>
    <wcs:TrimLow>"1950-01-01"</wcs:TrimLow>
    <wcs:TrimHigh>"1950-01-05"</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/28-get_coverage_trim_time.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 29-get_coverage_out_of_bound_slice_time.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Lat(30,31)&
subset=Long(30,35)&
subset=t("1950-01-07T12:00")

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 29-get_coverage_out_of_bound_slice_time.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:TrimLow>30</wcs:TrimLow>
    <wcs:TrimHigh>31</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:TrimLow>30</wcs:TrimLow>
    <wcs:TrimHigh>35</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionSlice>
    <wcs:Dimension>t</wcs:Dimension>
    <wcs:SlicePoint>"1950-01-07T12:00"</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 30-get_coverage_trim_asterisks.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
subset=j(*,*)&
subset=i(*,1)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/30-get_coverage_trim_asterisks.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 30-get_coverage_trim_asterisks.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:TrimLow>*</wcs:TrimLow>
    <wcs:TrimHigh>*</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>i</wcs:Dimension>
    <wcs:TrimLow>*</wcs:TrimLow>
    <wcs:TrimHigh>1</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/30-get_coverage_trim_asterisks.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 31-get_coverage_slice_asterisks.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
subset=j(*)

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 31-get_coverage_slice_asterisks.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:SlicePoint>*</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 32-describe_coverage_no_id.error.kvp

service=WCS&
version=2.0.1&
request=DescribeCoverage

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 32-describe_coverage_no_id.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:DescribeCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
</wcs:DescribeCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 33-get_coverage_no_id.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 33-get_coverage_no_id.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 34-get_coverage_minimum_bbox.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Lat(31)&
subset=Long(70,70.1)&
subset=t("1950-01-02")

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/34-get_coverage_minimum_bbox.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 34-get_coverage_minimum_bbox.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:SlicePoint>31</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionTrim>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:TrimLow>70</wcs:TrimLow>
    <wcs:TrimHigh>70.1</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionSlice>
    <wcs:Dimension>t</wcs:Dimension>
    <wcs:SlicePoint>"1950-01-02"</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/34-get_coverage_minimum_bbox.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 35-get_coverage_time_zone1.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Lat(31)&
subset=Long(70.1)&
subset=t("1950-01-01T12:00","1950-01-01T12Z")

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/35-get_coverage_time_zone1.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 35-get_coverage_time_zone1.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:SlicePoint>31</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:SlicePoint>70.1</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionTrim>
    <wcs:Dimension>t</wcs:Dimension>
    <wcs:TrimLow>"1950-01-01T12:00"</wcs:TrimLow>
    <wcs:TrimHigh>"1950-01-01T12Z"</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/35-get_coverage_time_zone1.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 36-get_coverage_time_zone2.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Lat(31)&
subset=Long(70.1)&
subset=t("1950-01-01T12-01","1950-01-01T12Z")

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 36-get_coverage_time_zone2.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:SlicePoint>31</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:SlicePoint>70.1</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionTrim>
    <wcs:Dimension>t</wcs:Dimension>
    <wcs:TrimLow>"1950-01-01T12-01"</wcs:TrimLow>
    <wcs:TrimHigh>"1950-01-01T12Z"</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 37-get_coverage_time_zone3.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Lat(31)&
subset=Long(70.1)&
subset=t("1950-01-01T12:00%2B14","1950-01-01T11:59:59.999%2B12")

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 37-get_coverage_time_zone3.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:SlicePoint>31</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:SlicePoint>70.1</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionTrim>
    <wcs:Dimension>t</wcs:Dimension>
    <wcs:TrimLow>"1950-01-01T12:00%2B14"</wcs:TrimLow>
    <wcs:TrimHigh>"1950-01-01T11:59:59.999%2B12"</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 38-get_coverage_trim_asterisk_time1.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Lat(30)&
subset=Long(66.6)&
subset=t("1950-01-05",*)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/38-get_coverage_trim_asterisk_time1.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 38-get_coverage_trim_asterisk_time1.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:SlicePoint>30</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:SlicePoint>66.6</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionTrim>
    <wcs:Dimension>t</wcs:Dimension>
    <wcs:TrimLow>"1950-01-05"</wcs:TrimLow>
    <wcs:TrimHigh>*</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/38-get_coverage_trim_asterisk_time1.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 39-get_coverage_trim_asterisk_time2.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Lat(30)&
subset=Long(66.6)&
subset=t(*,"1950-01-05")

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/39-get_coverage_trim_asterisk_time2.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 39-get_coverage_trim_asterisk_time2.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:SlicePoint>30</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:SlicePoint>66.6</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionTrim>
    <wcs:Dimension>t</wcs:Dimension>
    <wcs:TrimLow>*</wcs:TrimLow>
    <wcs:TrimHigh>"1950-01-05"</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/39-get_coverage_trim_asterisk_time2.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 40-get_coverage_trim_asterisk_time3.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=eobstest&
subset=Lat(30)&
subset=Long(66.6)&
subset=t(*,*)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/40-get_coverage_trim_asterisk_time3.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 40-get_coverage_trim_asterisk_time3.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>eobstest</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>Lat</wcs:Dimension>
    <wcs:SlicePoint>30</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>Long</wcs:Dimension>
    <wcs:SlicePoint>66.6</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionTrim>
    <wcs:Dimension>t</wcs:Dimension>
    <wcs:TrimLow>*</wcs:TrimLow>
    <wcs:TrimHigh>*</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/40-get_coverage_trim_asterisk_time3.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 41-get_coverage_untouched_irregular_axis.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_1&
subset=i(0,1)&
subset=j(3,4)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/41-get_coverage_untouched_irregular_axis.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 41-get_coverage_untouched_irregular_axis.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_1</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>i</wcs:Dimension>
    <wcs:TrimLow>0</wcs:TrimLow>
    <wcs:TrimHigh>1</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:TrimLow>3</wcs:TrimLow>
    <wcs:TrimHigh>4</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/41-get_coverage_untouched_irregular_axis.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 42-get_coverage_0D_referenceable.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_1&
subset=i(2)&
subset=j(5)&
subset=k(8)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/42-get_coverage_0D_referenceable.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 42-get_coverage_0D_referenceable.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_1</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>i</wcs:Dimension>
    <wcs:SlicePoint>2</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:SlicePoint>5</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>k</wcs:Dimension>
    <wcs:SlicePoint>8</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/42-get_coverage_0D_referenceable.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 43-get_coverage_fit_bbox_irregular_axis.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_1&
subset=i(0,2)&
subset=j(3,5)&
subset=k(4,7)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/43-get_coverage_fit_bbox_irregular_axis.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 43-get_coverage_fit_bbox_irregular_axis.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_1</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>i</wcs:Dimension>
    <wcs:TrimLow>0</wcs:TrimLow>
    <wcs:TrimHigh>2</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:TrimLow>3</wcs:TrimLow>
    <wcs:TrimHigh>5</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>k</wcs:Dimension>
    <wcs:TrimLow>4</wcs:TrimLow>
    <wcs:TrimHigh>7</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/43-get_coverage_fit_bbox_irregular_axis.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 44-get_coverage_trim_irr_time1.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_2&
subset=E(100000)&
subset=N(5100000)&
subset=ansi("2008-01-02","2008-01-06")

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/44-get_coverage_trim_irr_time1.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 44-get_coverage_trim_irr_time1.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_2</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>E</wcs:Dimension>
    <wcs:SlicePoint>100000</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>N</wcs:Dimension>
    <wcs:SlicePoint>5100000</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionTrim>
    <wcs:Dimension>ansi</wcs:Dimension>
    <wcs:TrimLow>"2008-01-02"</wcs:TrimLow>
    <wcs:TrimHigh>"2008-01-06"</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/44-get_coverage_trim_irr_time1.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 45-get_coverage_trim_irr_time2.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_2&
subset=E(100000)&
subset=N(5100000)&
subset=ansi(148654,148658)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/45-get_coverage_trim_irr_time2.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 45-get_coverage_trim_irr_time2.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_2</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>E</wcs:Dimension>
    <wcs:SlicePoint>100000</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>N</wcs:Dimension>
    <wcs:SlicePoint>5100000</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionTrim>
    <wcs:Dimension>ansi</wcs:Dimension>
    <wcs:TrimLow>148654</wcs:TrimLow>
    <wcs:TrimHigh>148658</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/45-get_coverage_trim_irr_time2.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 46-get_coverage_slice_irr_time1.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_2&
subset=E(100000,100666)&
subset=N(5100000,5123456)&
subset=ansi("2008-01-08")

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/46-get_coverage_slice_irr_time1.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 46-get_coverage_slice_irr_time1.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_2</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>E</wcs:Dimension>
    <wcs:TrimLow>100000</wcs:TrimLow>
    <wcs:TrimHigh>100666</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>N</wcs:Dimension>
    <wcs:TrimLow>5100000</wcs:TrimLow>
    <wcs:TrimHigh>5123456</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionSlice>
    <wcs:Dimension>ansi</wcs:Dimension>
    <wcs:SlicePoint>"2008-01-08"</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/46-get_coverage_slice_irr_time1.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 47-get_coverage_slice_irr_time2.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_2&
subset=E(100000,100666)&
subset=N(5100000,5123456)&
subset=ansi(148661)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/47-get_coverage_slice_irr_time2.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 47-get_coverage_slice_irr_time2.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_2</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>E</wcs:Dimension>
    <wcs:TrimLow>100000</wcs:TrimLow>
    <wcs:TrimHigh>100666</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>N</wcs:Dimension>
    <wcs:TrimLow>5100000</wcs:TrimLow>
    <wcs:TrimHigh>5123456</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionSlice>
    <wcs:Dimension>ansi</wcs:Dimension>
    <wcs:SlicePoint>148661</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/47-get_coverage_slice_irr_time2.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 48-get_coverage_gmljp2.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mean_summer_airtemp&
format=image/jp2&
mediatype=multipart/related

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 48-get_coverage_gmljp2.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mean_summer_airtemp</wcs:CoverageId>
  <gml:format>image/jp2</gml:format>
  <gml:mediaType>multipart/related</gml:mediaType>
</wcs:GetCoverage>

test.sh: image comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 49-get_coverage_interpolation_param.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
scalefactor=100&
interpolation=http://www.opengis.net/def/interpolation/OGC/0/nearest-neighbor

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/49-get_coverage_interpolation_param.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 49-get_coverage_interpolation_param.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xmlns:int="http://www.opengis.net/wcs/interpolation/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:Extension>
    <scal:Scaling>
      <scal:ScaleByFactor>
        <scal:scaleFactor>100</scal:scaleFactor>
      </scal:ScaleByFactor>
    </scal:Scaling>
    <int:Interpolation>
      <int:globalInterpolation>http://www.opengis.net/def/interpolation/OGC/0/nearest-neighbor</int:globalInterpolation>
    </int:Interpolation>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/49-get_coverage_interpolation_param.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 50-get_coverage_interpolation_param.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mr&
interpolation=foo

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 50-get_coverage_interpolation_param.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xmlns:int="http://www.opengis.net/wcs/interpolation/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>mr</wcs:CoverageId>
  <wcs:Extension>
    <int:Interpolation>
      <int:globalInterpolation>foo</int:globalInterpolation>
    </int:Interpolation>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 51-get_coverage_gridcov1.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=float_4d&
subset=i(0,0)&
subset=j(0,0)&
subset=k(10)&
subset=m(15)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/51-get_coverage_gridcov1.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 51-get_coverage_gridcov1.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>float_4d</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>i</wcs:Dimension>
    <wcs:TrimLow>0</wcs:TrimLow>
    <wcs:TrimHigh>0</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>j</wcs:Dimension>
    <wcs:TrimLow>0</wcs:TrimLow>
    <wcs:TrimHigh>0</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionSlice>
    <wcs:Dimension>k</wcs:Dimension>
    <wcs:SlicePoint>10</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:DimensionSlice>
    <wcs:Dimension>m</wcs:Dimension>
    <wcs:SlicePoint>15</wcs:SlicePoint>
  </wcs:DimensionSlice>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/51-get_coverage_gridcov1.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 52-get_coverage_gridcov2.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=double_1d&
subset=i(6,9)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/52-get_coverage_gridcov2.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 52-get_coverage_gridcov2.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>double_1d</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>i</wcs:Dimension>
    <wcs:TrimLow>6</wcs:TrimLow>
    <wcs:TrimHigh>9</wcs:TrimHigh>
  </wcs:DimensionTrim>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/52-get_coverage_gridcov2.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 53-get_coverage_insubset_gridcrs.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=mean_summer_airtemp&
subset=Long,CRS:1(400,401)&
subset=Lat,CRS:1(350,351)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/53-get_coverage_insubset_gridcrs.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 53-get_coverage_range_no_such_field.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=rgb&
rangesubset=fake_name

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 53-get_coverage_range_no_such_field.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:rsub="http://www.opengis.net/wcs/range-subsetting/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>rgb</wcs:CoverageId>
  <wcs:Extension>
    <rsub:rangeSubset>
      <rsub:rangeItem>
        <rsub:rangeComponent>fake_name</rsub:rangeComponent>
      </rsub:rangeItem>
    </rsub:rangeSubset>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 54-get_coverage_illegal_field_sequence.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=rgb&
rangesubset=green:red

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 54-get_coverage_illegal_field_sequence.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:rsub="http://www.opengis.net/wcs/range-subsetting/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>rgb</wcs:CoverageId>
  <wcs:Extension>
    <rsub:rangeSubset>
      <rsub:rangeItem>
        <rsub:rangeInterval>
          <rsub:startComponent>green</rsub:startComponent>
          <rsub:endComponent>red</rsub:endComponent>
        </rsub:rangeInterval>
      </rsub:rangeItem>
    </rsub:rangeSubset>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 55-get_coverage_scale_irregular1.error.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_2&
scalefactor=2.0

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 55-get_coverage_scale_irregular1.error.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_2</wcs:CoverageId>
  <wcs:Extension>
    <scal:Scaling>
      <scal:ScaleByFactor>
        <scal:scaleFactor>2.0</scal:scaleFactor>
      </scal:ScaleByFactor>
    </scal:Scaling>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: http exit code comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 56-get_coverage_scale_irregular1.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_2&
subset=ansi(148654)&
scalefactor=2.0

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/56-get_coverage_scale_irregular1.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 56-get_coverage_scale_irregular1.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_2</wcs:CoverageId>
  <wcs:DimensionSlice>
    <wcs:Dimension>ansi</wcs:Dimension>
    <wcs:SlicePoint>148654</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:Extension>
    <scal:Scaling>
      <scal:ScaleByFactor>
        <scal:scaleFactor>2.0</scal:scaleFactor>
      </scal:ScaleByFactor>
    </scal:Scaling>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/56-get_coverage_scale_irregular1.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 57-get_coverage_scale_irregular2.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_2&
subset=E(80000,90000)&
subset=N(5100000,5110000)&
subset=ansi(148653,148655)&
scaleaxes=E(2)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/57-get_coverage_scale_irregular2.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 57-get_coverage_scale_irregular2.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_2</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>E</wcs:Dimension>
    <wcs:TrimLow>80000</wcs:TrimLow>
    <wcs:TrimHigh>90000</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>N</wcs:Dimension>
    <wcs:TrimLow>5100000</wcs:TrimLow>
    <wcs:TrimHigh>5110000</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>ansi</wcs:Dimension>
    <wcs:TrimLow>148653</wcs:TrimLow>
    <wcs:TrimHigh>148655</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:Extension>
    <scal:Scaling>
      <scal:ScaleAxesByFactor>
        <scal:ScaleAxis>
          <scal:axis>E</scal:axis>
          <scal:scaleFactor>2</scal:scaleFactor>
        </scal:ScaleAxis>
      </scal:ScaleAxesByFactor>
    </scal:Scaling>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/57-get_coverage_scale_irregular2.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 58-get_coverage_scale_irregular3.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_2&
subset=E(80000,100000)&
subset=N(5100000,5124000)&
subset=ansi(148654)&
scalesize=E(2),N(2)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/58-get_coverage_scale_irregular3.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 58-get_coverage_scale_irregular3.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_2</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>E</wcs:Dimension>
    <wcs:TrimLow>80000</wcs:TrimLow>
    <wcs:TrimHigh>100000</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>N</wcs:Dimension>
    <wcs:TrimLow>5100000</wcs:TrimLow>
    <wcs:TrimHigh>5124000</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionSlice>
    <wcs:Dimension>ansi</wcs:Dimension>
    <wcs:SlicePoint>148654</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:Extension>
    <scal:Scaling>
      <scal:ScaleToSize>
        <scal:TargetAxisSize>
          <scal:axis>E</scal:axis>
          <scal:targetSize>2</scal:targetSize>
        </scal:TargetAxisSize>
        <scal:TargetAxisSize>
          <scal:axis>N</scal:axis>
          <scal:targetSize>2</scal:targetSize>
        </scal:TargetAxisSize>
      </scal:ScaleToSize>
    </scal:Scaling>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/58-get_coverage_scale_irregular3.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 59-get_coverage_scale_irregular4.kvp

service=WCS&
version=2.0.1&
request=GetCoverage&
coverageId=irr_cube_2&
subset=E(80000,100000)&
subset=N(5100000,5124000)&
subset=ansi(148654)&
scaleextent=E(0:0)

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/59-get_coverage_scale_irregular4.kvp.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 59-get_coverage_scale_irregular4.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCoverage
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xmlns:scal="http://www.opengis.net/wcs/scaling/1.0"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
  <wcs:CoverageId>irr_cube_2</wcs:CoverageId>
  <wcs:DimensionTrim>
    <wcs:Dimension>E</wcs:Dimension>
    <wcs:TrimLow>80000</wcs:TrimLow>
    <wcs:TrimHigh>100000</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionTrim>
    <wcs:Dimension>N</wcs:Dimension>
    <wcs:TrimLow>5100000</wcs:TrimLow>
    <wcs:TrimHigh>5124000</wcs:TrimHigh>
  </wcs:DimensionTrim>
  <wcs:DimensionSlice>
    <wcs:Dimension>ansi</wcs:Dimension>
    <wcs:SlicePoint>148654</wcs:SlicePoint>
  </wcs:DimensionSlice>
  <wcs:Extension>
    <scal:Scaling>
      <scal:ScaleToExtent>
        <scal:TargetAxisExtent>
          <scal:axis>E</scal:axis>
          <scal:low>0</scal:low>
          <scal:high>0</scal:high>
        </scal:TargetAxisExtent>
      </scal:ScaleToExtent>
    </scal:Scaling>
  </wcs:Extension>
</wcs:GetCoverage>

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/output/59-get_coverage_scale_irregular4.xml.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 60-get_capabilities_covsummary.kvp

service=WCS&
version=2.0.1&
request=GetCapabilities

test.sh: custom script
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------
running test: 60-get_capabilities_covsummary.xml

<?xml version="1.0" encoding="UTF-8"?>
<wcs:GetCapabilities
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:wcs="http://www.opengis.net/wcs/2.0"
    xmlns:gml="http://www.opengis.net/gml/3.2"
    xsi:schemaLocation="http://schemas.opengis.net/wcs/2.0 ../wcsAll.xsd"
    service="WCS" version="2.0.1">
</wcs:GetCapabilities>

test.sh: custom script
test.sh:  ->  TEST PASSED
--------------------------------------------------------------------------------------------

test.sh: -------------------------------------------------------
test.sh: Test summary
test.sh: 
test.sh:   Test finished at: Tue Jul  1 13:20:51 CEST 2014
test.sh:   Total tests run : 113
test.sh:   Successful tests: 109
test.sh:   Failed tests    : 4
test.sh:   Skipped tests   : 0
test.sh:   Detail test log : /home/rasdaman/rasdaman/systemtest/testcases_services/test_wcs/log
test.sh: -------------------------------------------------------


test.sh: starting test at Tue Jul  1 13:20:51 CEST 2014
test.sh: 
test.sh: Testing service: wms
test.sh: rgb already imported.
test.sh: mr already imported.
test.sh: eobstest already imported.
test.sh: mean_summer_airtemp already imported.
test.sh: mean_summer_airtemp_repeat already imported.
test.sh: float_4d already imported.
test.sh: double_1d already imported.
test.sh: irr_cube_1 already imported.
test.sh: irr_cube_2 already imported.

running test: WMS-01-getCapabilities.test

service=WMS
&version=1.1.0
&request=GetCapabilities

test.sh: Preparing XML file /home/rasdaman/rasdaman/systemtest/testcases_services/test_wms/output/WMS-01-getCapabilities.test.out for oracle comparison... ok.
test.sh: byte comparison
test.sh:  -> TEST SKIPPED
--------------------------------------------------------------------------------------------

test.sh: -------------------------------------------------------
test.sh: Test summary
test.sh: 
test.sh:   Test finished at: Tue Jul  1 13:20:55 CEST 2014
test.sh:   Total tests run : 1
test.sh:   Successful tests: 0
test.sh:   Failed tests    : 0
test.sh:   Skipped tests   : 1
test.sh:   Detail test log : /home/rasdaman/rasdaman/systemtest/testcases_services/test_wms/log
test.sh: -------------------------------------------------------


TEST SUMMARY

testcases_mandatory/test_conversion/test.sh ... FAIL
        see detail in testcases_mandatory/test_conversion/log
testcases_mandatory/test_manipulation/test.sh ... OK
        see detail in testcases_mandatory/test_manipulation/log
testcases_mandatory/test_select/test.sh ... FAIL
        see detail in testcases_mandatory/test_select/log
testcases_mandatory/test_tiling/test.sh ... OK
        see detail in testcases_mandatory/test_tiling/log
testcases_mandatory/test_user/test.sh ... OK
        see detail in testcases_mandatory/test_user/log
testcases_open/test_select/test.sh ... OK
        see detail in testcases_open/test_select/log
testcases_open/test_tickets/test.sh ... OK
        see detail in testcases_open/test_tickets/log
testcases_fixed/test_memleak/test.sh ... OK
        see detail in testcases_fixed/test_memleak/log
testcases_services/test_secore/test.sh ... FAIL
        see detail in testcases_services/test_secore/log
testcases_services/test_wcps/test.sh ... FAIL
        see detail in testcases_services/test_wcps/log
testcases_services/test_wcs/test.sh ... FAIL
        see detail in testcases_services/test_wcs/log
testcases_services/test_wms/test.sh ... OK
        see detail in testcases_services/test_wms/log