utPLSQL · jgebal · Dec 21, 2016 · Dec 16, 2016 · Dec 17, 2016 · Dec 17, 2016
diff --git a/source/core/ut_utils.pkb b/source/core/ut_utils.pkb
@@ -114,6 +114,16 @@ create or replace package body ut_utils is
   begin
     return coalesce(to_char(a_value,gc_timestamp_format), gc_null_string);
   end;
+
+  function to_string(a_value yminterval_unconstrained) return varchar2 IS
+  begin
+    return coalesce(to_char(a_value), gc_null_string);
+  end;
+
+  function to_string(a_value dsinterval_unconstrained) return varchar2 IS 
+  begin
+    return coalesce(to_char(a_value), gc_null_string);
+  end;
 
 
   function boolean_to_int(a_value boolean) return integer is

diff --git a/source/core/ut_utils.pks b/source/core/ut_utils.pks
@@ -28,15 +28,15 @@ create or replace package ut_utils authid definer is
   ex_unsupported_rollback_type exception;
   gc_unsupported_rollback_type constant pls_integer := -20200;
   pragma exception_init(ex_unsupported_rollback_type, -20200);
-  
+
   ex_path_list_is_empty exception;
   gc_path_list_is_empty constant pls_integer := -20201;
   pragma exception_init(ex_path_list_is_empty, -20201);
 
   ex_invalid_path_format exception;
   gc_invalid_path_format constant pls_integer := -20202;
   pragma exception_init(ex_invalid_path_format, -20202);
-  
+
 
   gc_max_output_string_length constant integer := 4000;
   gc_max_input_string_length  constant integer := gc_max_output_string_length - 2; --we need to remove 2 chars for quotes around string
@@ -84,6 +84,10 @@ create or replace package ut_utils authid definer is
 
   function to_string(a_value timestamp_ltz_unconstrained) return varchar2;
 
+  function to_string(a_value yminterval_unconstrained) return varchar2;
+
+  function to_string(a_value dsinterval_unconstrained) return varchar2;
+
   function boolean_to_int(a_value boolean) return integer;
 
   function int_to_boolean(a_value integer) return boolean;

diff --git a/source/expectations/data_values/ut_data_value_dsinterval.tpb b/source/expectations/data_values/ut_data_value_dsinterval.tpb
@@ -0,0 +1,21 @@
+create or replace type body ut_data_value_dsinterval as
+
+  constructor function ut_data_value_dsinterval(self in out nocopy ut_data_value_dsinterval, a_value dsinterval_unconstrained) return self as result is
+  begin
+    self.datavalue := a_value;
+    self.datatype := 'day to second interval';
+    return;
+  end;
+
+  overriding member function is_null return boolean is
+  begin
+    return (self.datavalue is null);
+  end;
+
+  overriding member function to_string return varchar2 is
+  begin
+    return ut_utils.to_string(self.datavalue);
+  end;
+
+end;
+/
diff --git a/source/expectations/data_values/ut_data_value_dsinterval.tps b/source/expectations/data_values/ut_data_value_dsinterval.tps
@@ -0,0 +1,7 @@
+create or replace type ut_data_value_dsinterval under ut_data_value(
+  datavalue dsinterval_unconstrained,
+  constructor function ut_data_value_dsinterval(self in out nocopy ut_data_value_dsinterval, a_value dsinterval_unconstrained) return self as result,
+  overriding member function is_null return boolean,
+  overriding member function to_string return varchar2
+)
+/
diff --git a/source/expectations/data_values/ut_data_value_yminterval.tpb b/source/expectations/data_values/ut_data_value_yminterval.tpb
@@ -0,0 +1,21 @@
+create or replace type body ut_data_value_yminterval as
+
+  constructor function ut_data_value_yminterval(self in out nocopy ut_data_value_yminterval, a_value yminterval_unconstrained) return self as result is
+  begin
+    self.datavalue := a_value;
+    self.datatype := 'year to month interval';
+    return;
+  end;
+
+  overriding member function is_null return boolean is
+  begin
+    return (self.datavalue is null);
+  end;
+
+  overriding member function to_string return varchar2 is
+  begin
+    return ut_utils.to_string(self.datavalue);
+  end;
+
+end;
+/
diff --git a/source/expectations/data_values/ut_data_value_yminterval.tps b/source/expectations/data_values/ut_data_value_yminterval.tps
@@ -0,0 +1,7 @@
+create or replace type ut_data_value_yminterval under ut_data_value(
+  datavalue yminterval_unconstrained,
+  constructor function ut_data_value_yminterval(self in out nocopy ut_data_value_yminterval, a_value yminterval_unconstrained) return self as result,
+  overriding member function is_null return boolean,
+  overriding member function to_string return varchar2
+)
+/
diff --git a/source/expectations/matchers/be_between.tpb b/source/expectations/matchers/be_between.tpb
@@ -44,6 +44,20 @@ create or replace type body be_between is
     init(ut_data_value_timestamp_ltz(a_lower_bound), ut_data_value_timestamp_ltz(a_upper_bound));
     return;
   end;
+
+  constructor function be_between(self in out nocopy be_between, a_lower_bound yminterval_unconstrained, a_upper_bound yminterval_unconstrained)
+    return self as result is   
+  begin
+    init(ut_data_value_yminterval(a_lower_bound), ut_data_value_yminterval(a_upper_bound));
+    return;  
+  end;
+
+  constructor function be_between(self in out nocopy be_between, a_lower_bound dsinterval_unconstrained, a_upper_bound dsinterval_unconstrained)
+    return self as result is   
+  begin
+    init(ut_data_value_dsinterval(a_lower_bound), ut_data_value_dsinterval(a_upper_bound));
+    return;   
+  end;  
 
   overriding member function run_matcher(self in out nocopy be_between, a_actual ut_data_value) return boolean is
     l_result boolean;
@@ -96,6 +110,22 @@ create or replace type body be_between is
       begin
         l_result := l_actual.datavalue between l_lower.datavalue and l_upper.datavalue;
       end;
+    elsif self.lower_bound is of(ut_data_value_yminterval) and self.upper_bound is of(ut_data_value_yminterval) and a_actual is of(ut_data_value_yminterval) then
+      declare
+        l_lower  ut_data_value_yminterval := treat(self.lower_bound as ut_data_value_yminterval);
+        l_upper  ut_data_value_yminterval := treat(self.upper_bound as ut_data_value_yminterval);
+        l_actual ut_data_value_yminterval := treat(a_actual as ut_data_value_yminterval);
+      begin
+        l_result := l_actual.datavalue between l_lower.datavalue and l_upper.datavalue;
+      end;
+    elsif self.lower_bound is of(ut_data_value_dsinterval) and self.upper_bound is of(ut_data_value_dsinterval) and a_actual is of(ut_data_value_dsinterval) then
+      declare
+        l_lower  ut_data_value_dsinterval := treat(self.lower_bound as ut_data_value_dsinterval);
+        l_upper  ut_data_value_dsinterval := treat(self.upper_bound as ut_data_value_dsinterval);
+        l_actual ut_data_value_dsinterval := treat(a_actual as ut_data_value_dsinterval);
+      begin
+        l_result := l_actual.datavalue between l_lower.datavalue and l_upper.datavalue;
+      end;
     else
       l_result := (self as ut_matcher).run_matcher(a_actual);
     end if;

diff --git a/source/expectations/matchers/be_between.tps b/source/expectations/matchers/be_between.tps
@@ -17,6 +17,10 @@ create or replace type be_between under ut_matcher
     return self as result,
   constructor function be_between(self in out nocopy be_between, a_lower_bound timestamp_ltz_unconstrained, a_upper_bound timestamp_ltz_unconstrained)
     return self as result,
+  constructor function be_between(self in out nocopy be_between, a_lower_bound yminterval_unconstrained, a_upper_bound yminterval_unconstrained)
+    return self as result,
+  constructor function be_between(self in out nocopy be_between, a_lower_bound dsinterval_unconstrained, a_upper_bound dsinterval_unconstrained)
+    return self as result,
 
   overriding member function run_matcher(self in out nocopy be_between, a_actual ut_data_value) return boolean
 )

diff --git a/source/expectations/matchers/be_greater_or_equal.tpb b/source/expectations/matchers/be_greater_or_equal.tpb
@@ -0,0 +1,110 @@
+create or replace type body be_greater_or_equal AS
+
+  member procedure init(self in out nocopy be_greater_or_equal, a_expected ut_data_value) is
+  begin
+    self.name := lower($$plsql_unit);
+    self.expected := a_expected;
+  end;
+
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected date) return self as result is
+  begin
+    init(ut_data_value_date(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected NUMBER) return self as result is
+  begin
+    init(ut_data_value_number(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected timestamp_unconstrained) return self as result is
+  begin
+    init(ut_data_value_timestamp(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected timestamp_tz_unconstrained) return self as result is
+  begin
+    init(ut_data_value_timestamp_tz(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected timestamp_ltz_unconstrained) return self as result is
+  begin
+    init(ut_data_value_timestamp_ltz(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected yminterval_unconstrained) return self as RESULT IS
+  begin
+    init(ut_data_value_yminterval(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected dsinterval_unconstrained) return self as RESULT IS
+  begin
+    init(ut_data_value_dsinterval(a_expected));
+    return;
+  end;
+
+  overriding member function run_matcher(self in out nocopy be_greater_or_equal, a_actual ut_data_value) return boolean is
+    l_result boolean;
+  begin
+    if self.expected is of (ut_data_value_date) and a_actual is of (ut_data_value_date) then
+      declare
+        l_expected ut_data_value_date := treat(self.expected as ut_data_value_date);
+        l_actual   ut_data_value_date := treat(a_actual as ut_data_value_date);
+      begin
+        l_result := l_actual.datavalue >= l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_number) and a_actual is of (ut_data_value_number) then
+      declare
+        l_expected ut_data_value_number := treat(self.expected as ut_data_value_number);
+        l_actual   ut_data_value_number := treat(a_actual as ut_data_value_number);
+      begin
+        l_result := l_actual.datavalue >= l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_timestamp) and a_actual is of (ut_data_value_timestamp) then
+      declare
+        l_expected ut_data_value_timestamp := treat(self.expected as ut_data_value_timestamp);
+        l_actual   ut_data_value_timestamp := treat(a_actual as ut_data_value_timestamp);
+      begin
+        l_result := l_actual.datavalue >= l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_timestamp_ltz) and a_actual is of (ut_data_value_timestamp_ltz) then
+      declare
+        l_expected ut_data_value_timestamp_ltz := treat(self.expected as ut_data_value_timestamp_ltz);
+        l_actual   ut_data_value_timestamp_ltz := treat(a_actual as ut_data_value_timestamp_ltz);
+      begin
+        l_result := l_actual.datavalue >= l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_timestamp_tz) and a_actual is of (ut_data_value_timestamp_tz) then
+      declare
+        l_expected ut_data_value_timestamp_tz := treat(self.expected as ut_data_value_timestamp_tz);
+        l_actual   ut_data_value_timestamp_tz := treat(a_actual as ut_data_value_timestamp_tz);
+      begin
+        l_result := l_actual.datavalue >= l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_yminterval) and a_actual is of (ut_data_value_yminterval) then
+      declare
+        l_expected ut_data_value_yminterval := treat(self.expected as ut_data_value_yminterval);
+        l_actual   ut_data_value_yminterval := treat(a_actual as ut_data_value_yminterval);
+      begin
+        l_result := l_actual.datavalue >= l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_dsinterval) and a_actual is of (ut_data_value_dsinterval) then
+      declare
+        l_expected ut_data_value_dsinterval := treat(self.expected as ut_data_value_dsinterval);
+        l_actual   ut_data_value_dsinterval := treat(a_actual as ut_data_value_dsinterval);
+      begin
+        l_result := l_actual.datavalue >= l_expected.datavalue;
+      end;            
+    else
+      l_result := (self as ut_matcher).run_matcher(a_actual);
+    end if;
+    return l_result;
+  end;
+
+END;
+/
diff --git a/source/expectations/matchers/be_greater_or_equal.tps b/source/expectations/matchers/be_greater_or_equal.tps
@@ -0,0 +1,12 @@
+create or replace type be_greater_or_equal under ut_matcher(  
+  member procedure init(self in out nocopy be_greater_or_equal, a_expected ut_data_value),
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected date) return self as result,
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected number) return self as result,
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected timestamp_unconstrained) return self as result,
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected timestamp_tz_unconstrained) return self as result,
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected timestamp_ltz_unconstrained) return self as result,
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected yminterval_unconstrained) return self as result,
+  constructor function be_greater_or_equal(self in out nocopy be_greater_or_equal, a_expected dsinterval_unconstrained) return self as result,
+  overriding member function run_matcher(self in out nocopy be_greater_or_equal, a_actual ut_data_value) return boolean  
+)
+/
diff --git a/source/expectations/matchers/be_greater_than.tpb b/source/expectations/matchers/be_greater_than.tpb
@@ -0,0 +1,110 @@
+create or replace type body be_greater_than AS
+
+  member procedure init(self in out nocopy be_greater_than, a_expected ut_data_value) is
+  begin
+    self.name := lower($$plsql_unit);
+    self.expected := a_expected;
+  end;
+
+  constructor function be_greater_than(self in out nocopy be_greater_than, a_expected date) return self as result is
+  begin
+    init(ut_data_value_date(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_than(self in out nocopy be_greater_than, a_expected NUMBER) return self as result is
+  begin
+    init(ut_data_value_number(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_than(self in out nocopy be_greater_than, a_expected timestamp_unconstrained) return self as result is
+  begin
+    init(ut_data_value_timestamp(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_than(self in out nocopy be_greater_than, a_expected timestamp_tz_unconstrained) return self as result is
+  begin
+    init(ut_data_value_timestamp_tz(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_than(self in out nocopy be_greater_than, a_expected timestamp_ltz_unconstrained) return self as result is
+  begin
+    init(ut_data_value_timestamp_ltz(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_than(self in out nocopy be_greater_than, a_expected yminterval_unconstrained) return self as RESULT IS
+  begin
+    init(ut_data_value_yminterval(a_expected));
+    return;
+  end;
+
+  constructor function be_greater_than(self in out nocopy be_greater_than, a_expected dsinterval_unconstrained) return self as RESULT IS
+  begin
+    init(ut_data_value_dsinterval(a_expected));
+    return;
+  end;
+
+  overriding member function run_matcher(self in out nocopy be_greater_than, a_actual ut_data_value) return boolean is
+    l_result boolean;
+  begin
+    if self.expected is of (ut_data_value_date) and a_actual is of (ut_data_value_date) then
+      declare
+        l_expected ut_data_value_date := treat(self.expected as ut_data_value_date);
+        l_actual   ut_data_value_date := treat(a_actual as ut_data_value_date);
+      begin
+        l_result := l_actual.datavalue > l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_number) and a_actual is of (ut_data_value_number) then
+      declare
+        l_expected ut_data_value_number := treat(self.expected as ut_data_value_number);
+        l_actual   ut_data_value_number := treat(a_actual as ut_data_value_number);
+      begin
+        l_result := l_actual.datavalue > l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_timestamp) and a_actual is of (ut_data_value_timestamp) then
+      declare
+        l_expected ut_data_value_timestamp := treat(self.expected as ut_data_value_timestamp);
+        l_actual   ut_data_value_timestamp := treat(a_actual as ut_data_value_timestamp);
+      begin
+        l_result := l_actual.datavalue > l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_timestamp_ltz) and a_actual is of (ut_data_value_timestamp_ltz) then
+      declare
+        l_expected ut_data_value_timestamp_ltz := treat(self.expected as ut_data_value_timestamp_ltz);
+        l_actual   ut_data_value_timestamp_ltz := treat(a_actual as ut_data_value_timestamp_ltz);
+      begin
+        l_result := l_actual.datavalue > l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_timestamp_tz) and a_actual is of (ut_data_value_timestamp_tz) then
+      declare
+        l_expected ut_data_value_timestamp_tz := treat(self.expected as ut_data_value_timestamp_tz);
+        l_actual   ut_data_value_timestamp_tz := treat(a_actual as ut_data_value_timestamp_tz);
+      begin
+        l_result := l_actual.datavalue > l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_yminterval) and a_actual is of (ut_data_value_yminterval) then
+      declare
+        l_expected ut_data_value_yminterval := treat(self.expected as ut_data_value_yminterval);
+        l_actual   ut_data_value_yminterval := treat(a_actual as ut_data_value_yminterval);
+      begin
+        l_result := l_actual.datavalue > l_expected.datavalue;
+      end;
+    elsif self.expected is of (ut_data_value_dsinterval) and a_actual is of (ut_data_value_dsinterval) then
+      declare
+        l_expected ut_data_value_dsinterval := treat(self.expected as ut_data_value_dsinterval);
+        l_actual   ut_data_value_dsinterval := treat(a_actual as ut_data_value_dsinterval);
+      begin
+        l_result := l_actual.datavalue > l_expected.datavalue;
+      end;            
+    else
+      l_result := (self as ut_matcher).run_matcher(a_actual);
+    end if;
+    return l_result;
+  end;
+
+END;
+/