Changeset 5

Timestamp:

08/16/08 12:38:29 (4 years ago)

Author:

fumanchu

Message:

New assertion methods: assert_void, assert_less_than, assert_greater_than, assert_greater_than_or_equal.

Location:

trunk/epic

Files:

• epic.sql (modified) (4 diffs)
• test/test_asserts.sql (modified) (8 diffs)

trunk/epic/epic.sql

@@ -95 +95 @@
         to assert anything that can be evaluated to a boolean. For example,
         PERFORM test.assert(substring(a from b), b||" not found in "||a);
-    * test.assert_equal(1 anyelement, 2 anyelement)
-    * test.assert_not_equal(1 anyelement, 2 anyelement)
-    * test.assert_less_than(1 anyelement, 2 anyelement)
+    * test.assert_void(call text)
+    * test.assert_equal(elem_1 anyelement, elem_2 anyelement)
+    * test.assert_not_equal(elem_1 anyelement, elem_2 anyelement)
+    * test.assert_greater_than(elem_1 anyelement, elem_2 anyelement)
+    * test.assert_greater_than_or_equal(elem_1 anyelement, elem_2 anyelement)
+    * test.assert_less_than(elem_1 anyelement, elem_2 anyelement)
+    * test.assert_less_than_or_equal(elem_1 anyelement, elem_2 anyelement)
     * test.assert_values(column text, source text, expected anyarray):
         Raises an exception if SELECT column FROM source != expected.
     
     * test.assert_raises(call text, errm text, state text): Raises an
-      exception if 'SELECT * FROM [call];' does not raise errm.
+        exception if 'SELECT * FROM [call];' does not raise errm
+        (if provided) or state (if provided).
 
 Some return dynamic SQL:
@@ -290 +295 @@
 
 
+CREATE OR REPLACE FUNCTION test.assert_void(call text) RETURNS VOID AS $$
+-- Raises an exception if SELECT * FROM call != void.
+DECLARE
+  retval    text;
+BEGIN
+  EXECUTE ('SELECT * FROM ' || call || ';') INTO retval;
+  IF retval != '' THEN
+    RAISE EXCEPTION 'Call: ''%'' did not return void. Got ''%'' instead.', call, retval;
+  END IF;
+END;
+$$ LANGUAGE plpgsql;
+
+
 CREATE OR REPLACE FUNCTION test.assert(assertion boolean, msg text) RETURNS VOID AS $$
 -- Raises an exception (msg) if assertion is false.
@@ -334 +352 @@
 
 
+CREATE OR REPLACE FUNCTION test.assert_less_than(elem_1 anyelement, elem_2 anyelement) RETURNS VOID AS $$
+-- Raises an exception if elem_1 >= elem_2
+-- 
+-- The two arguments must be of the same type. If they are not,
+-- you will receive "ERROR:  invalid input syntax ..."
+BEGIN
+  IF (elem_1 IS NULL or elem_2 IS NULL) THEN
+    RAISE EXCEPTION 'Assertion arguments may not be NULL.';
+  END IF;
+  IF NOT (elem_1 < elem_2) THEN
+    RAISE EXCEPTION '% not < %', elem_1, elem_2;
+  END IF;
+END;
+$$ LANGUAGE plpgsql;
+
+
 CREATE OR REPLACE FUNCTION test.assert_less_than_or_equal(elem_1 anyelement, elem_2 anyelement) RETURNS VOID AS $$
 -- Raises an exception if elem_1 > elem_2
@@ -345 +379 @@
   IF NOT (elem_1 <= elem_2) THEN
     RAISE EXCEPTION '% not <= %', elem_1, elem_2;
+  END IF;
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION test.assert_greater_than(elem_1 anyelement, elem_2 anyelement) RETURNS VOID AS $$
+-- Raises an exception if elem_1 <= elem_2
+-- 
+-- The two arguments must be of the same type. If they are not,
+-- you will receive "ERROR:  invalid input syntax ..."
+BEGIN
+  IF (elem_1 IS NULL or elem_2 IS NULL) THEN
+    RAISE EXCEPTION 'Assertion arguments may not be NULL.';
+  END IF;
+  IF NOT (elem_1 > elem_2) THEN
+    RAISE EXCEPTION '% not > %', elem_1, elem_2;
+  END IF;
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION test.assert_greater_than_or_equal(elem_1 anyelement, elem_2 anyelement) RETURNS VOID AS $$
+-- Raises an exception if elem_1 < elem_2
+-- 
+-- The two arguments must be of the same type. If they are not,
+-- you will receive "ERROR:  invalid input syntax ..."
+BEGIN
+  IF (elem_1 IS NULL or elem_2 IS NULL) THEN
+    RAISE EXCEPTION 'Assertion arguments may not be NULL.';
+  END IF;
+  IF NOT (elem_1 >= elem_2) THEN
+    RAISE EXCEPTION '% not >= %', elem_1, elem_2;
   END IF;
 END;

trunk/epic/test/test_asserts.sql

@@ +1 @@
+-- Tests for the various assert_* functions which Epic provides.
+-- To run, execute epic.sql, then this script, then test.run_module('test_asserts').
+
 SET search_path = test, public, pg_catalog;
 
@@ -94 +97 @@
 
 
+CREATE OR REPLACE FUNCTION test.test_assert_void() RETURNS VOID AS $$
+-- Assert the correct operation of test.assert_void
+-- module: test_asserts
+DECLARE
+  retval    text;
+BEGIN
+  -- assert_void() MUST return VOID if the given call returns VOID.
+  SELECT INTO retval * FROM test.assert_void('pg_sleep(0.1)');
+  IF retval != '' THEN
+    RAISE EXCEPTION 'assert_void did not itself return void. Got ''%'' instead.', retval;
+  END IF;
+  
+  -- assert_void() MUST raise an exception if the given call does not return void.
+  PERFORM test.assert_raises('test.assert_void(''pg_namespace'')', 
+    'Call: ''pg_namespace'' did not return void. Got ''pg_toast'' instead.',
+    'P0001');
+  
+  RAISE EXCEPTION '[OK]';
+END;
+$$ LANGUAGE plpgsql;
+
+
 CREATE OR REPLACE FUNCTION test.test_assert_equal() RETURNS VOID AS $$
 -- Assert the correct operation of test.assert_equal
@@ -101 +126 @@
 BEGIN
   -- assert_equal() MUST return VOID if the given assertion holds.
-  SELECT INTO retval * FROM test.assert_equal(1, 1);
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_equal() did not return void for (1, 1).';
-  END IF;
-  SELECT INTO retval * FROM test.assert_equal('abc'::text, 'abc');
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_equal() did not return void for (''abc'', ''abc'').';
-  END IF;
+  PERFORM test.assert_void('test.assert_equal(1, 1)');
+  PERFORM test.assert_void('test.assert_equal(''abc''::text, ''abc'');');
+  
+  -- assert_equal() MUST return VOID if both args are null.
+  PERFORM test.assert_void('test.assert_equal(NULL::int, NULL);');
   
   -- assert_equal() MUST raise an exception if the given assertion does not hold.
   PERFORM test.assert_raises('test.assert_equal(1, 2)', '1 != 2', 'P0001');
-  
   PERFORM test.assert_raises('test.assert_equal(''abc''::text, ''xyz'')', 'abc != xyz', 'P0001');
-  
-  -- assert_equal() MUST return VOID if both args are null.
-  SELECT INTO retval * FROM test.assert_equal(NULL::int, NULL);
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_equal() did not return void for (null, null).';
-  END IF;
   
   -- assert_equal() MUST raise an exception if only one arg is NULL.
@@ -142 +157 @@
 BEGIN
   -- assert_not_equal() MUST return VOID if the given assertion does not hold.
-  SELECT INTO retval * FROM test.assert_not_equal(1, 2);
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_not_equal() did not return void for (1, 2).';
-  END IF;
-  SELECT INTO retval * FROM test.assert_not_equal('abc'::text, 'xyz');
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_not_equal() did not return void for (''abc'', ''xyz'').';
-  END IF;
+  PERFORM test.assert_void('test.assert_not_equal(1, 2);');
+  PERFORM test.assert_void('test.assert_not_equal(''abc''::text, ''xyz'');');
+  
+  -- assert_not_equal() MUST return VOID if only one arg is NULL.
+  PERFORM test.assert_void('test.assert_not_equal(8, NULL);');
+  PERFORM test.assert_void('test.assert_not_equal(NULL, 7);');
   
   -- assert_not_equal() MUST raise an exception if the given assertion holds.
@@ -155 +168 @@
   PERFORM test.assert_raises('test.assert_not_equal(''abc''::text, ''abc'')', 'abc = abc', 'P0001');
   
-  -- assert_not_equal() MUST return VOID if only one arg is NULL.
-  SELECT INTO retval * FROM test.assert_not_equal(8, NULL);
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_not_equal() did not return void for (8, null).';
-  END IF;
-  SELECT INTO retval * FROM test.assert_not_equal(NULL, 7);
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_not_equal() did not return void for (null, 7).';
-  END IF;
-  
   -- assert_not_equal() MUST raise an exception if both args are NULL.
   PERFORM test.assert_raises('test.assert_not_equal(NULL::int, NULL)', '<NULL> = <NULL>', 'P0001');
@@ -178 +181 @@
 
 
+CREATE OR REPLACE FUNCTION test.test_assert_less_than() RETURNS VOID AS $$
+-- Assert the correct operation of test.assert_less_than
+-- module: test_asserts
+DECLARE
+  retval    text;
+BEGIN
+  -- assert_less_than() MUST return VOID if a < b.
+  PERFORM test.assert_void('test.assert_less_than(1, 2);');
+  PERFORM test.assert_void('test.assert_less_than(''abc''::text, ''xyz'');');
+  
+  -- assert_less_than() MUST raise an exception if a >= b.
+  PERFORM test.assert_raises('test.assert_less_than(2, 1)', '2 not < 1', 'P0001');
+  PERFORM test.assert_raises('test.assert_less_than(1, 1)', '1 not < 1', 'P0001');
+  PERFORM test.assert_raises('test.assert_less_than(''abc''::text, ''abc'')', 
+    'abc not < abc', 'P0001');
+  PERFORM test.assert_raises('test.assert_less_than(''xyz''::text, ''abc'')', 
+    'xyz not < abc', 'P0001');
+  
+  -- assert_less_than() MUST raise an exception if either arg is NULL.
+  PERFORM test.assert_raises('test.assert_less_than(NULL::int, NULL)', 
+    'Assertion arguments may not be NULL.', 'P0001');
+  
+  -- assert_less_than() will raise an undefined_function exception if the args have different types.
+  -- It would be nice to find a way around this (without writing M x N overloaded funcs).
+  PERFORM test.assert_raises('test.assert_less_than(8, ''abc''::text)', 
+    'function test.assert_less_than(integer, text) does not exist', '42883');
+  
+  RAISE EXCEPTION '[OK]';
+END;
+$$ LANGUAGE plpgsql;
+
+
 CREATE OR REPLACE FUNCTION test.test_assert_less_than_or_equal() RETURNS VOID AS $$
 -- Assert the correct operation of test.assert_less_than_or_equal
@@ -185 +220 @@
 BEGIN
   -- assert_less_than_or_equal() MUST return VOID if a <= b.
-  SELECT INTO retval * FROM test.assert_less_than_or_equal(1, 2);
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_less_than_or_equal() did not return void for (1, 2).';
-  END IF;
-  SELECT INTO retval * FROM test.assert_less_than_or_equal(1, 1);
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_less_than_or_equal() did not return void for (1, 1).';
-  END IF;
-  SELECT INTO retval * FROM test.assert_less_than_or_equal('abc'::text, 'xyz');
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_less_than_or_equal() did not return void for (''abc'', ''xyz'').';
-  END IF;
-  SELECT INTO retval * FROM test.assert_less_than_or_equal('abc'::text, 'abc');
-  IF retval != '' THEN
-    RAISE EXCEPTION 'test.assert_less_than_or_equal() did not return void for (''abc'', ''abc'').';
-  END IF;
+  PERFORM test.assert_void('test.assert_less_than_or_equal(1, 2);');
+  PERFORM test.assert_void('test.assert_less_than_or_equal(1, 1);');
+  PERFORM test.assert_void('test.assert_less_than_or_equal(''abc''::text, ''xyz'');');
+  PERFORM test.assert_void('test.assert_less_than_or_equal(''abc''::text, ''abc'');');
   
   -- assert_less_than_or_equal() MUST raise an exception if a > b.
@@ -215 +238 @@
   PERFORM test.assert_raises('test.assert_less_than_or_equal(8, ''abc''::text)', 
     'function test.assert_less_than_or_equal(integer, text) does not exist', '42883');
+  
+  RAISE EXCEPTION '[OK]';
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION test.test_assert_greater_than() RETURNS VOID AS $$
+-- Assert the correct operation of test.assert_greater_than
+-- module: test_asserts
+DECLARE
+  retval    text;
+BEGIN
+  -- assert_greater_than() MUST return VOID if a > b.
+  PERFORM test.assert_void('test.assert_greater_than(2, 1);');
+  PERFORM test.assert_void('test.assert_greater_than(''xyz''::text, ''abc'');');
+  
+  -- assert_greater_than() MUST raise an exception if a <= b.
+  PERFORM test.assert_raises('test.assert_greater_than(1, 2)', '1 not > 2', 'P0001');
+  PERFORM test.assert_raises('test.assert_greater_than(1, 1)', '1 not > 1', 'P0001');
+  PERFORM test.assert_raises('test.assert_greater_than(''abc''::text, ''abc'')', 
+    'abc not > abc', 'P0001');
+  PERFORM test.assert_raises('test.assert_greater_than(''abc''::text, ''xyz'')', 
+    'abc not > xyz', 'P0001');
+  
+  -- assert_greater_than() MUST raise an exception if either arg is NULL.
+  PERFORM test.assert_raises('test.assert_greater_than(NULL::int, NULL)', 
+    'Assertion arguments may not be NULL.', 'P0001');
+  
+  -- assert_greater_than() will raise an undefined_function exception if the args have different types.
+  -- It would be nice to find a way around this (without writing M x N overloaded funcs).
+  PERFORM test.assert_raises('test.assert_greater_than(8, ''abc''::text)', 
+    'function test.assert_greater_than(integer, text) does not exist', '42883');
+  
+  RAISE EXCEPTION '[OK]';
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION test.test_assert_greater_than_or_equal() RETURNS VOID AS $$
+-- Assert the correct operation of test.assert_greater_than_or_equal
+-- module: test_asserts
+DECLARE
+  retval    text;
+BEGIN
+  -- assert_greater_than_or_equal() MUST return VOID if a >= b.
+  PERFORM test.assert_void('test.assert_greater_than_or_equal(2, 1);');
+  PERFORM test.assert_void('test.assert_greater_than_or_equal(1, 1);');
+  PERFORM test.assert_void('test.assert_greater_than_or_equal(''xyz''::text, ''abc'');');
+  PERFORM test.assert_void('test.assert_greater_than_or_equal(''abc''::text, ''abc'');');
+  
+  -- assert_greater_than_or_equal() MUST raise an exception if a < b.
+  PERFORM test.assert_raises('test.assert_greater_than_or_equal(1, 2)', '1 not >= 2', 'P0001');
+  PERFORM test.assert_raises('test.assert_greater_than_or_equal(''abc''::text, ''xyz'')', 
+    'abc not >= xyz', 'P0001');
+  
+  -- assert_greater_than_or_equal() MUST raise an exception if either arg is NULL.
+  PERFORM test.assert_raises('test.assert_greater_than_or_equal(NULL::int, NULL)', 
+    'Assertion arguments may not be NULL.', 'P0001');
+  
+  -- assert_greater_than_or_equal() will raise an undefined_function exception if the args have different types.
+  -- It would be nice to find a way around this (without writing M x N overloaded funcs).
+  PERFORM test.assert_raises('test.assert_greater_than_or_equal(8, ''abc''::text)', 
+    'function test.assert_greater_than_or_equal(integer, text) does not exist', '42883');
   
   RAISE EXCEPTION '[OK]';