Renamed ut_include to ut_contain.

utPLSQL · jgebal · Mar 15, 2019 · Oct 6, 2018 · Oct 6, 2018 · Oct 6, 2018
commit dd7e86869d69421011b23aa0b164cf89a158fd2d
diff --git a/docs/userguide/advanced_data_comparison.md b/docs/userguide/advanced_data_comparison.md
@@ -15,9 +15,9 @@ Advanced data-comparison options are available for the [`equal`](expectations.md
   ut.expect( a_actual {data-type} ).not_to( equal( a_expected {data-type})[.extendend_option()[.extendend_option()[...]]]) );
   ut.expect( a_actual {data-type} ).to_equal( a_expected {data-type})[.extendend_option()[.extendend_option()[...]]]);
   ut.expect( a_actual {data-type} ).not_to_equal( a_expected {data-type})[.extendend_option()[.extendend_option()[...]]] );
+  ut.expect( a_actual {data-type} ).to_( contain( a_expected {data-type})[.extendend_option()[.extendend_option()[...]]]);
+  ut.expect( a_actual {data-type} ).not_to( contain( a_expected {data-type})[.extendend_option()[.extendend_option()[...]]]) );
   ut.expect( a_actual {data-type} ).to_contain( a_expected {data-type})[.extendend_option()[.extendend_option()[...]]]);
-  ut.expect( a_actual {data-type} ).to_include( a_expected {data-type})[.extendend_option()[.extendend_option()[...]]]);
-  ut.expect( a_actual {data-type} ).not_to_include( a_expected {data-type})[.extendend_option()[.extendend_option()[...]]]);
   ut.expect( a_actual {data-type} ).not_to_contain( a_expected {data-type})[.extendend_option()[.extendend_option()[...]]]);
 ```
 
@@ -61,7 +61,7 @@ procedure test_cur_skip_columns_cn is
 begin
   open l_expected for select 'text' ignore_me, d.* from user_tables d where rownum = 1;
   open l_actual   for select sysdate "ADate",  d.* from user_tables d;
-  ut.expect( l_actual ).to_include( l_expected ).exclude( 'IGNORE_ME,ADate' );
+  ut.expect( l_actual ).to_contain( l_expected ).exclude( 'IGNORE_ME,ADate' );
 end;
 ```
 
@@ -230,7 +230,7 @@ end;
 Above test will indicate that in actual data-set
 
 ```sql
-     Actual: refcursor [ count = 43 ] was expected to include: refcursor [ count = 44 ]
+     Actual: refcursor [ count = 43 ] was expected to contain: refcursor [ count = 44 ]
      Diff:
      Rows: [ 1 differences ]
        PK <USERNAME>TEST</USERNAME> - Missing   <USER_ID>-610</USER_ID>
@@ -404,7 +404,7 @@ create or replace package body test_unordered_columns as
     and rownum < 20;
 
     --Assert
-    ut.expect(l_actual).to_include(l_expected).unordered_columns();
+    ut.expect(l_actual).to_contain(l_expected).unordered_columns();
   end;
 end;
 /

diff --git a/docs/userguide/expectations.md b/docs/userguide/expectations.md
@@ -145,7 +145,7 @@ utPLSQL provides the following matchers to perform checks on the expected and ac
 - `be_null`
 - `be_true`
 - `equal`
-- `include ` / `contain`
+- `contain`
 - `have_count`
 - `match`
 
@@ -433,17 +433,17 @@ end;
 The `a_nulls_are_equal` parameter controls the behavior of a `null = null` comparison.
 To change the behavior of `NULL = NULL` comparison pass the `a_nulls_are_equal => false` to the `equal` matcher.  
 
-## include / contain
+## contain
 
 This matcher supports only cursor comparison. It check if the give set contain all values from given subset.
 
-when comparing data using `include / contain` matcher, the data-types of columns for compared cursors must be exactly the same.
+When comparing data using `contain` matcher, the data-types of columns for compared cursors must be exactly the same.
 
-The matcher supports all advanced comparison options as `equal` e.g. include , exclude, join_by.
+The matcher supports all advanced comparison options as `equal` like: `include` , `exclude`, `join_by` etc..
 
-The matcher is successful when all of the values from expected results are included in actual data set.
+The matcher is successful when actual data set contains all of the values from expected results.
 
-The matcher will cause a test to fail if any of expected values are not included in actual data set.
+The matcher will cause a test to fail if actual data set does not contain any of expected values.
 
 ![included_set](../images/venn21.gif)
 
@@ -460,23 +460,23 @@ The matcher will cause a test to fail if any of expected values are not included
     union all select rownum as rn from dual a connect by level < 4;
 
     --Act
-    ut.expect(l_actual).to_include(l_expected);
+    ut.expect(l_actual).to_contain(l_expected);
   end;
 ```
 
 Will result in failure message
 
 ```sql
   1) ut_refcursors
-      Actual: refcursor [ count = 9 ] was expected to include: refcursor [ count = 6 ]
+      Actual: refcursor [ count = 9 ] was expected to contain: refcursor [ count = 6 ]
       Diff:
       Rows: [ 3 differences ]
       Missing:  <ROW><RN>3</RN></ROW>
       Missing:  <ROW><RN>2</RN></ROW>
       Missing:  <ROW><RN>1</RN></ROW>
 ```
 
-When duplicate rows are present in expected data set, actual data set must also include the same amount of duplicate.
+When duplicate rows are present in expected data set, actual data set must also include the same amount of duplicates.
 
 *Example 2.*
 
@@ -488,19 +488,19 @@ create or replace package ut_duplicate_test is
    --%suite(Sample Test Suite)
 
    --%test(Ref Cursor contain duplicates)
-   procedure ut_duplicate_include;
+   procedure ut_duplicate_contain;
 
 end ut_duplicate_test;
 /
 
 create or replace package body ut_duplicate_test is
-  procedure ut_duplicate_include is
+  procedure ut_duplicate_contain is
     l_actual   sys_refcursor;
     l_expected sys_refcursor;
   begin
     open l_expected for select mod(level,2) as rn from dual connect by level < 5;
     open l_actual   for select mod(level,8) as rn from dual connect by level < 9;
-    ut.expect(l_actual).to_include(l_expected);
+    ut.expect(l_actual).to_contain(l_expected);
    end;
 
 end ut_duplicate_test;
@@ -509,8 +509,8 @@ end ut_duplicate_test;
 Will result in failure test message
 
 ```sql
-  1) ut_duplicate_include
-      Actual: refcursor [ count = 8 ] was expected to include: refcursor [ count = 4 ]
+  1) ut_duplicate_contain
+      Actual: refcursor [ count = 8 ] was expected to contain: refcursor [ count = 4 ]
       Diff:
       Rows: [ 2 differences ]
       Missing:  <RN>0</RN>
@@ -519,7 +519,7 @@ Will result in failure test message
 
 
 
-The negated version of `include / contain` ( `not_to_include`/ `not_to_contain` ) is successful only when all values from expected set are not part of actual (they are disjoint and there is no overlap).
+The negated version of `contain` ( `not_to_contain` ) is successful only when all values from expected set are not part of actual (they are disjoint and there is no overlap).
 
 
 
@@ -531,7 +531,7 @@ Set 1 is defined as [ A , B , C ]
 
 *Set 2 is defined as [A , D , E ]*
 
-*Result : This will fail both of options to`to_include` and `not_to_include`*
+*Result : This will fail both of options to `to_contain` and `not_to_contain`*
 
 
 
@@ -541,7 +541,7 @@ Set 1 is defined as [ A , B , C , D ]
 
 *Set 2 is defined as [A , B , D ]*
 
-*Result : This will be success on option `to_include` and fail `not_to_include`*
+*Result : This will be success on option `to_contain` and fail `not_to_contain`*
 
 
 
@@ -551,33 +551,33 @@ Set 1 is defined as [ A , B , C  ]
 
 *Set 2 is defined as [D, E , F  ]*
 
-*Result : This will be success on options `not_to_include` and fail  `to_include`* 
+*Result : This will be success on options `not_to_contain` and fail  `to_contain`* 
 
 
 
 Example usage
 
 ```sql
-create or replace package example_include is
-  --%suite(Include test)
+create or replace package example_contain is
+  --%suite(Contain test)
 
-  --%test( Cursor include data from another cursor)   
-  procedure cursor_to_include;
+  --%test( Cursor contains data from another cursor)   
+  procedure cursor_to_contain;
 
-  --%test( Cursor include data from another cursor)   
-  procedure cursor_not_to_include;
+  --%test( Cursor contains data from another cursor)   
+  procedure cursor_not_to_contain;
 
-  --%test( Cursor fail include)   
-  procedure cursor_fail_include;
+  --%test( Cursor fail on to_contain)   
+  procedure cursor_fail_contain;
 
-  --%test( Cursor fail not include)  
-  procedure cursor_fail_not_include;
+  --%test( Cursor fail not_to_contain)  
+  procedure cursor_fail_not_contain;
 end;
 /
 
-create or replace package body example_include is
+create or replace package body example_contain is
 
-  procedure cursor_to_include is
+  procedure cursor_to_contain is
     l_actual   SYS_REFCURSOR;
     l_expected SYS_REFCURSOR;
   begin
@@ -594,10 +594,10 @@ create or replace package body example_include is
     select 'c' as name from dual;
 
     --Act
-    ut.expect(l_actual).to_include(l_expected);
+    ut.expect(l_actual).to_contain(l_expected);
   end;
 
-  procedure cursor_not_to_include is
+  procedure cursor_not_to_contain is
     l_actual   SYS_REFCURSOR;
     l_expected SYS_REFCURSOR;
   begin
@@ -613,10 +613,10 @@ create or replace package body example_include is
     select 'f' as name from dual;
 
     --Act
-    ut.expect(l_actual).not_to_include(l_expected);
+    ut.expect(l_actual).not_to_contain(l_expected);
   end;
 
-  procedure cursor_fail_include is
+  procedure cursor_fail_contain is
     l_actual   SYS_REFCURSOR;
     l_expected SYS_REFCURSOR;
   begin
@@ -632,10 +632,10 @@ create or replace package body example_include is
     select 'e' as name from dual;
 
     --Act
-    ut.expect(l_actual).to_include(l_expected);
+    ut.expect(l_actual).to_contain(l_expected);
   end;
 
-  procedure cursor_fail_not_include is
+  procedure cursor_fail_not_contain is
     l_actual   SYS_REFCURSOR;
     l_expected SYS_REFCURSOR;
   begin
@@ -651,7 +651,7 @@ create or replace package body example_include is
     select 'e' as name from dual;
 
     --Act
-    ut.expect(l_actual).not_to_include(l_expected);
+    ut.expect(l_actual).not_to_contain(l_expected);
   end;
 end;
 /
@@ -660,26 +660,30 @@ end;
 
 
 Above execution will provide results as follow:
+Cursor contains data from another cursor   
+Cursor contains data from another cursor   
+Cursor fail on to_contain   
+Cursor fail not_to_contain  
 
 ```sql
-Include test
-  Cursor include data from another cursor [.045 sec]
-  Cursor include data from another cursor [.039 sec]
-  Cursor fail include [.046 sec] (FAILED - 1)
-  Cursor fail not include [.043 sec] (FAILED - 2)
+Contain test
+  Cursor contains data from another cursor [.045 sec]
+  Cursor contains data from another cursor [.039 sec]
+  Cursor fail on to_contain [.046 sec] (FAILED - 1)
+  Cursor fail not_to_contain [.043 sec] (FAILED - 2)
 
 Failures:
 
-  1) cursor_fail_include
-      Actual: refcursor [ count = 3 ] was expected to include: refcursor [ count = 3 ]
+  1) cursor_fail_contain
+      Actual: refcursor [ count = 3 ] was expected to contain: refcursor [ count = 3 ]
       Diff:
       Rows: [ 2 differences ]
       Missing:  <ROW><NAME>d</NAME></ROW>
       Missing:  <ROW><NAME>e</NAME></ROW>
-      at "UT3.EXAMPLE_INCLUDE.CURSOR_FAIL_INCLUDE", line 71 ut.expect(l_actual).to_include(l_expected);
+      at "UT3.EXAMPLE_CONTAIN.CURSOR_FAIL_CONTAIN", line 71 ut.expect(l_actual).to_contain(l_expected);
 
 
-  2) cursor_fail_not_include
+  2) cursor_fail_not_contain
       Actual: (refcursor [ count = 3 ])
           Data-types:
           <ROW><NAME xml_valid_name="NAME">CHAR</NAME>
@@ -688,15 +692,15 @@ Failures:
           <ROW><NAME>a</NAME></ROW>
           <ROW><NAME>b</NAME></ROW>
           <ROW><NAME>c</NAME></ROW>
-      was expected not to include:(refcursor [ count = 3 ])
+      was expected not to contain:(refcursor [ count = 3 ])
           Data-types:
           <ROW><NAME xml_valid_name="NAME">CHAR</NAME>
           </ROW>
           Data:
           <ROW><NAME>a</NAME></ROW>
           <ROW><NAME>d</NAME></ROW>
           <ROW><NAME>e</NAME></ROW>
-      at "UT3.EXAMPLE_INCLUDE.CURSOR_FAIL_NOT_INCLUDE", line 94 ut.expect(l_actual).not_to_include(l_expected);
+      at "UT3.EXAMPLE_CONTAIN.CURSOR_FAIL_NOT_CONTAIN", line 94 ut.expect(l_actual).not_to_contain(l_expected);
 ```
 
 
@@ -1161,7 +1165,7 @@ The matrix below illustrates the data types supported by different matchers.
 | **be_less_than**        |      |         |      |  X   |   X    |     X     |               X               |                   X                    |          |                X                |                X                |        |                             |        |
 | **be_between**          |      |         |      |  X   |   X    |     X     |               X               |                   X                    |    X     |                X                |                X                |        |                             |        |
 | **equal**               |  X   |    X    |  X   |  X   |   X    |     X     |               X               |                   X                    |    X     |                X                |                X                |   X    |              X              |   X    |
-| **include / contain**   |      |         |      |      |        |           |                               |                                        |          |                                 |                                 |   X    |              X              |   X    |
+| **contain**             |      |         |      |      |        |           |                               |                                        |          |                                 |                                 |   X    |              X              |   X    |
 | **match**               |      |         |  X   |      |        |           |                               |                                        |    X     |                                 |                                 |        |                             |        |
 | **be_like**             |      |         |  X   |      |        |           |                               |                                        |    X     |                                 |                                 |        |                             |        |
 | **be_empty**            |  X   |         |  X   |      |        |           |                               |                                        |          |                                 |                                 |   X    |              X              |        |

diff --git a/source/api/contain.syn b/source/api/contain.syn
@@ -1 +1 @@
-create synonym contain for ut_include;
+create synonym contain for ut_contain;
diff --git a/source/api/include.syn b/source/api/include.syn
diff --git a/source/create_synonyms_and_grants_for_public.sql b/source/create_synonyms_and_grants_for_public.sql
@@ -124,10 +124,9 @@ create public synonym be_like for &&ut3_owner..be_like;
 create public synonym be_not_null for &&ut3_owner..be_not_null;
 create public synonym be_null for &&ut3_owner..be_null;
 create public synonym be_true for &&ut3_owner..be_true;
-create public synonym contain for &&ut3_owner..include;
+create public synonym contain for &&ut3_owner..contain;
 create public synonym equal for &&ut3_owner..equal;
 create public synonym have_count for &&ut3_owner..have_count;
-create public synonym include for &&ut3_owner..include;
 create public synonym match for &&ut3_owner..match;
 
 create public synonym ut for &&ut3_owner..ut;

diff --git a/source/create_user_synonyms.sql b/source/create_user_synonyms.sql
@@ -68,6 +68,7 @@ create or replace synonym &ut3_user..be_like for &&ut3_owner..be_like;
 create or replace synonym &ut3_user..be_not_null for &&ut3_owner..be_not_null;
 create or replace synonym &ut3_user..be_null for &&ut3_owner..be_null;
 create or replace synonym &ut3_user..be_true for &&ut3_owner..be_true;
+create or replace synonym &ut3_user..contain for &&ut3_owner..contain;
 create or replace synonym &ut3_user..equal for &&ut3_owner..equal;
 create or replace synonym &ut3_user..have_count for &&ut3_owner..have_count;
 create or replace synonym &ut3_user..match for &&ut3_owner..match;

diff --git a/source/expectations/matchers/ut_include.tpb → source/expectations/matchers/ut_contain.tpb b/source/expectations/matchers/ut_include.tpb → source/expectations/matchers/ut_contain.tpb
@@ -1,4 +1,4 @@
-create or replace type body ut_include as
+create or replace type body ut_contain as
   /*
   utPLSQL - Version 3
   Copyright 2016 - 2018 utPLSQL Project
@@ -16,14 +16,14 @@ create or replace type body ut_include as
   limitations under the License.
   */
 
-  constructor function ut_include(self in out nocopy ut_include, a_expected sys_refcursor) return self as result is
+  constructor function ut_contain(self in out nocopy ut_contain, a_expected sys_refcursor) return self as result is
   begin
     self.init(ut_data_value_refcursor(a_expected), null, $$plsql_unit);
     self.options.unordered();
     return;
   end;
 
-  overriding member function run_matcher(self in out nocopy ut_include, a_actual ut_data_value) return boolean is
+  overriding member function run_matcher(self in out nocopy ut_contain, a_actual ut_data_value) return boolean is
     l_result boolean;
   begin
     if self.expected.data_type = a_actual.data_type then
@@ -38,7 +38,7 @@ create or replace type body ut_include as
     return l_result;
   end;
 
-  overriding member function run_matcher_negated(self in out nocopy ut_include, a_actual ut_data_value) return boolean is
+  overriding member function run_matcher_negated(self in out nocopy ut_contain, a_actual ut_data_value) return boolean is
   begin
     return run_matcher(a_actual);
   end;

diff --git a/source/expectations/matchers/ut_include.tps → source/expectations/matchers/ut_contain.tps b/source/expectations/matchers/ut_include.tps → source/expectations/matchers/ut_contain.tps
@@ -1,4 +1,4 @@
-create or replace type ut_include under ut_equal(
+create or replace type ut_contain under ut_equal(
   /*
   utPLSQL - Version 3
   Copyright 2016 - 2018 utPLSQL Project
@@ -23,9 +23,9 @@ create or replace type ut_include under ut_equal(
   * that false include not necessary mean true not include.
   */
 
-  constructor function ut_include(self in out nocopy ut_include, a_expected sys_refcursor) return self as result,
-  overriding member function run_matcher(self in out nocopy ut_include, a_actual ut_data_value) return boolean,
-  overriding member function run_matcher_negated(self in out nocopy ut_include, a_actual ut_data_value) return boolean,
+  constructor function ut_contain(self in out nocopy ut_contain, a_expected sys_refcursor) return self as result,
+  overriding member function run_matcher(self in out nocopy ut_contain, a_actual ut_data_value) return boolean,
+  overriding member function run_matcher_negated(self in out nocopy ut_contain, a_actual ut_data_value) return boolean,
   overriding member function failure_message(a_actual ut_data_value) return varchar2,
   overriding member function failure_message_when_negated(a_actual ut_data_value) return varchar2
 )
Original file line number	Diff line number	Diff line change
		@@ -1 +1 @@
		create synonym contain for ut_include;
		create synonym contain for ut_contain;