echo "validate html"

HTML_FILENAME="coverage.html"

EXCLUSION_REGEX=".*Element\s.?ol.?\snot\sallowed\sas\schild\sof\selement\s.?pre.*"

HTML_VALIDATOR_URL="https://validator.w3.org/nu/"

VALIDATOR_OUT="gnu"

WARNING_REGEX="info warning:"

ERROR_REGEX="error:"

VALIDATION_RESULTS=$(curl -H "Content-Type: text/html; charset=utf-8" --data-binary @$HTML_FILENAME "$HTML_VALIDATOR_URL?out=$VALIDATOR_OUT&filterpattern=$EXCLUSION_REGEX")

ERROR_COUNT=`echo "$VALIDATION_RESULTS" | grep -c "$ERROR_REGEX"`

WARNING_COUNT=`echo "$VALIDATION_RESULTS" | grep -c "$WARNING_REGEX"`

echo "There are $ERROR_COUNT errors, $WARNING_COUNT warning in $HTML_FILENAME"

if [ $ERROR_COUNT -gt 0 ]; then

echo "$VALIDATION_RESULTS" | grep "$ERROR_REGEX"

exit 1

exit 0

- `unordered` - perform compare on unordered set of data, return only missing or actual

- `join_by(a_columns varchar2)` - columns or comma seperated list of columns to join two cursors by

- `join_by(a_columns ut_varchar2_list)` - table of columns to join two cursors by

##Unordered

Unordered option allows for quick comparison of two cursors without need of ordering them in any way.

Result of such comparison will be limited to only information about row existing or not existing in given set without actual information about exact differences.

procedure unordered_tst is

l_actual sys_refcursor;

l_expected sys_refcursor;

open l_expected for select username, user_id from all_users

union all

select 'TEST' username, -600 user_id from dual

order by 1 desc;

open l_actual for select username, user_id from all_users

union all

select 'TEST' username, -610 user_id from dual

order by 1 asc;

ut.expect( l_actual ).to_equal( l_expected ).unordered;

end;

Above test will result in two differences of one row extra and one row missing.

Diff:

Rows: [ 2 differences ]

Missing: <ROW><USERNAME>TEST</USERNAME><USER_ID>-600</USER_ID></ROW>

Extra: <ROW><USERNAME>TEST</USERNAME><USER_ID>-610</USER_ID></ROW>

You can now join two cursors by defining a primary key or composite key that will be used to uniquely identify and compare rows. This option allows us to exactly show which rows are missing, extra and which are different without ordering clause. In the situation where the join key is not unique, join will partition set over rows with a same key and join on row number as well as given join key. The extra rows or missing will be presented to user as well as not matching rows.

Join by option can be used in conjunction with include or exclude options. However if any of the join keys is part of exclude set, comparison will fail and report to user that sets could not be joined on specific key (excluded).

procedure join_by_username is

l_actual sys_refcursor;

l_expected sys_refcursor;

open l_expected for select username, user_id from all_users

union all

select 'TEST' username, -600 user_id from dual

order by 1 desc;

open l_actual for select username, user_id from all_users

union all

select 'TEST' username, -610 user_id from dual

order by 1 asc;

ut.expect( l_actual ).to_equal( l_expected ).join_by('USERNAME');

end;

This will show you difference in row 'TEST' regardless of order.

Rows: [ 1 differences ]

PK <USERNAME>TEST</USERNAME> - Expected: <USER_ID>-600</USER_ID>

PK <USERNAME>TEST</USERNAME> - Actual: <USER_ID>-610</USER_ID>

Assumption is that join by is made by column name so that what will be displayed as part of results.

Join by options currently doesn't support nested table inside cursor comparison, however is still possible to compare a collection as a whole.

Example.

procedure compare_collection_in_rec is

l_actual sys_refcursor;

l_expected sys_refcursor;

l_actual_tab ut3.ut_annotated_object;

l_expected_tab ut3.ut_annotated_object;

l_expected_message varchar2(32767);

l_actual_message varchar2(32767);

begin

select ut3.ut_annotated_object('TEST','TEST','TEST',

ut3.ut_annotations(ut3.ut_annotation(1,'test','test','test'),

ut3.ut_annotation(2,'test','test','test'))

)

into l_actual_tab from dual;

select ut3.ut_annotated_object('TEST','TEST','TEST',

ut3.ut_annotations(ut3.ut_annotation(1,'test','test','test'),

ut3.ut_annotation(2,'test','test','test'))

)

into l_expected_tab from dual;

--Arrange

open l_actual for select l_actual_tab as nested_table from dual;

open l_expected for select l_expected_tab as nested_table from dual;

--Act

ut3.ut.expect(l_actual).to_equal(l_expected).join_by('NESTED_TABLE/ANNOTATIONS');

end;

In case when a there is detected collection inside cursor and we cannot join key. Comparison will present a failed joins and also a message about collection being detected.

Actual: refcursor [ count = 1 ] was expected to equal: refcursor [ count = 1 ]

Diff:

Unable to join sets:

Join key NESTED_TABLE/ANNOTATIONS/TEXT does not exists in expected

Join key NESTED_TABLE/ANNOTATIONS/TEXT does not exists in actual

Please make sure that your join clause is not refferring to collection element

**Please note that .join_by option will take longer to process due to need of parsing via primary keys.**