Revised the test and example files of the "Phone Number" exercise.

- The tests expecting errors now check custom errors instead of error
messages.

- The example test has been modified so that it passes the modified tests.

Author: borderite

exercises/practice/phone-number/.meta/example.el

@@ -2,6 +2,16 @@
 
 ;;; Commentary:
 
+(define-error 'short-phone-num-error "must not be fewer than 10 digits")
+(define-error 'long-phone-num-error "must not be greater than 11 digits")
+(define-error 'letters-in-phone-num-error "letters not permitted")
+(define-error 'punctuations-in-phone-num-error "punctuations not permitted")
+(define-error 'country-code-error "country code must be 1")
+(define-error 'area-code-starting-with-0-error "area code cannot start with zero")
+(define-error 'area-code-starting-with-1-error "area code cannot start with one")
+(define-error 'exchange-code-starting-with-0-error "exchange code cannot start with zero")
+(define-error 'exchange-code-starting-with-1-error "exchange code cannot start with one")
+
 (defun char-digit-p (x)
   (<= ?0 x ?9))
 
@@ -42,30 +52,30 @@
   "Converts a num string into a string of digits."
   (cond
    ((cl-find-if #'char-alphabetic-p num)
-    (error "letters not permitted"))
+    (signal 'letters-in-phone-num-error num))
    ((cl-find-if #'char-punctuation-p num)
-    (error "punctuations not permitted")))
+    (signal 'punctuations-in-phone-num-error num)))
   (let* ((digits (string-remove num (negate #'char-digit-p)))
          (n (length digits)))
     (cond
-     ((< n 10) (error "must not be fewer than 10 digits"))
-     ((> n 11) (error "must not be greater than 11 digits")))
+     ((< n 10) (signal 'short-phone-num-error num))
+     ((> n 11) (signal 'long-phone-num-error num)))
     (if (= n 11)
         (if (= (aref digits 0) ?1)
             (setf digits (substring digits 1))
-          (error "11 digits must start with 1")))
+          (signal 'country-code-error num)))
     (let ((y (aref digits 0)))
       (cond
        ((= y ?0)
-        (error "area code cannot start with zero"))
+        (signal 'area-code-starting-with-0-error num))
        ((= y ?1)
-        (error "area code cannot start with one"))))
+        (signal 'area-code-starting-with-1-error num)))
     (let ((y (aref digits 3)))
       (cond
        ((= y ?0)
-        (error "exchange code cannot start with zero"))
+        (signal 'exchange-code-starting-with-0-error num))
        ((= y ?1)
-        (error "exchange code cannot start with one"))))
+        (signal 'exchange-code-starting-with-1-error num)))))
     digits))
 
 (defun area-code (num)

exercises/practice/phone-number/phone-number-test.el

@@ -19,12 +19,10 @@
   (should (string= (numbers "223 456   7890   ") "2234567890")))
 
 (ert-deftest invalid-when-9-digits ()
-  (should (string= (cadr (should-error (numbers "123456789")))
-                   "must not be fewer than 10 digits")))
+  (should-error (numbers "123456789") :type 'short-phone-num-error))
 
 (ert-deftest invalid-when-11-digits-does-not-start-with-a-1 ()
-  (should (string= (cadr (should-error (numbers "22234567890")))
-                   "11 digits must start with 1")))
+  (should-error (numbers "22234567890") :type 'country-code-error))
 
 (ert-deftest valid-when-11-digits-and-starting-with-1 ()
   (should (string= (numbers "12234567890") "2234567890")))
@@ -33,48 +31,37 @@
   (should (string= (numbers "+1 (223) 456-7890") "2234567890")))
 
 (ert-deftest invalid-when-more-than-11-digits ()
-  (should (string= (cadr (should-error (numbers "321234567890")))
-                   "must not be greater than 11 digits")))
+  (should-error (numbers "321234567890") :type 'long-phone-num-error))
 
 (ert-deftest invalid-with-letters ()
-  (should (string= (cadr (should-error (numbers "523-abc-7890")))
-                   "letters not permitted")))
+  (should-error (numbers "523-abc-7890") :type 'letters-in-phone-num-error))
 
 (ert-deftest invalid-with-punctuations ()
-  (should (string= (cadr (should-error (numbers "523-@:!-7890")))
-                   "punctuations not permitted")))
+  (should-error (numbers "523-@:!-7890") :type 'punctuations-in-phone-num-error))
 
 (ert-deftest invalid-if-area-code-starts-with-0 ()
-  (should (string= (cadr (should-error (numbers "(023) 456-7890")))
-                   "area code cannot start with zero")))
+  (should-error (numbers "(023) 456-7890") :type 'area-code-starting-with-0-error))
 
 (ert-deftest invalid-if-area-code-starts-with-1 ()
-  (should (string= (cadr (should-error (numbers "(123) 456-7890")))
-                   "area code cannot start with one")))
+  (should-error (numbers "(123) 456-7890") :type 'area-code-starting-with-1-error))
 
 (ert-deftest invalid-if-exchange-code-starts-with-0 ()
-  (should (string= (cadr (should-error (numbers "(223) 056-7890")))
-                   "exchange code cannot start with zero")))
+  (should-error (numbers "(223) 056-7890") :type 'exchange-code-starting-with-0-error))
 
 (ert-deftest invalid-if-exchange-code-starts-with-1 ()
-  (should (string= (cadr (should-error (numbers "(223) 156-7890")))
-                   "exchange code cannot start with one")))
+  (should-error (numbers "(223) 156-7890")  :type 'exchange-code-starting-with-1-error))
 
 (ert-deftest invalid-if-area-code-starts-with-0-on-valid-11-digit-number ()
-  (should (string= (cadr (should-error (numbers "1 (023) 456-7890")))
-                   "area code cannot start with zero")))
+  (should-error (numbers "1 (023) 456-7890") :type 'area-code-starting-with-0-error))
 
 (ert-deftest invalid-if-area-code-starts-with-1-on-valid-11-digit-number ()
-  (should (string= (cadr (should-error (numbers "1 (123) 456-7890")))
-                   "area code cannot start with one")))
+  (should-error (numbers "1 (123) 456-7890") :type 'area-code-starting-with-1-error))
 
 (ert-deftest invalid-if-exchange-code-starts-with-0-on-valid-11-digit-number ()
-  (should (string= (cadr (should-error (numbers "1 (223) 056-7890")))
-                   "exchange code cannot start with zero")))
+  (should-error (numbers "1 (223) 056-7890") :type 'exchange-code-starting-with-0-error))
 
 (ert-deftest invalid-if-exchange-code-starts-with-1-on-valid-11-digit-number ()
-  (should (string= (cadr (should-error (numbers "1 (223) 156-7890")))
-                   "exchange code cannot start with one")))
+  (should-error (numbers "1 (223) 156-7890") :type 'exchange-code-starting-with-1-error))
 
 (ert-deftest area-code-test ()
   (should (equal (area-code "2234567890") "223")))