trackler 2.2.1.105 → 2.2.1.106

data/tracks/bash/docs/ABOUT.md

@@ -1,5 +1,25 @@
-Although most users think of the shell as an interactive command interpreter, it is really a programming language in which each statement runs a command. Because it must satisfy both the interactive and programming aspects of command execution, it is a strange language, shaped as much by history as by design.  —- Brian Kernighan & Rob Pike
+Bash is the language that you will learn to love!
 
+Many of your everyday computer tasks can be done using the concise scripts it can produce.
+You will soon learn that while most things can be done through a Graphical User Interface, it can actually be vastly faster to use this powerful language!
+The command interpreter typically runs in a text window, where users may input commands (operations may also come from some files, also known as Bash scripts).
 
-cite: Kernighan, Brian W.; Pike, Rob (1984). The UNIX Programming Environment. Englewood Cliffs: Prentice-Hall. ISBN 0-13-937699-2.
+More formally, Bash (an acronym for **B**ourne-**a**gain **sh**ell, a pun around the Bourne shell and the term "born-again") is a Unix command interpreter.
+Offering a number of improvements over several other shells (Bash's has some useful functionality in regards to command history, job control and command line editing).
+
+A really good way to think about Bash is the following:
+
+> Although most users think of the shell as an interactive command interpreter, it is really a programming language in which each statement runs a command.
+> Because it must satisfy both the interactive and programming aspects of command execution, it is a strange language, shaped as much by history as by design.  —- Brian Kernighan & Rob Pike
+
+_cite: Kernighan, Brian W.; Pike, Rob (1984). The UNIX Programming Environment. Englewood Cliffs: Prentice-Hall. ISBN 0-13-937699-2._
+
+Though it was first released several decades ago after being written by Brian Fox of the Free Software Foundation, Bash is still used across the world every day!
+From automation to stitching a project together, the language is still as versatile as it ever was.
+Another benefit of the language's age is the rich documentation you'll find surrounding it.
+If you're ever stuck and don't know exactly how to implement an exercise, a great place to start is the built-in help, available through the use of `info bash` or `man bash`. 
+
+This track is to help you gain some experience in this wonderful scripting language.
+
+**Happy Bash'ing**
 

data/tracks/c/exercises/bob/README.md

@@ -6,6 +6,8 @@ Bob answers 'Sure.' if you ask him a question.
 
 He answers 'Whoa, chill out!' if you yell at him.
 
+He answers 'Calm down, I know what I'm doing!' if you yell a question at him.
+
 He says 'Fine. Be that way!' if you address him without actually saying
 anything.
 

data/tracks/c/exercises/bob/src/example.c

@@ -12,9 +12,8 @@ char *hey_bob(char *greeting)
    char ch = greeting[i];
 
    while (ch != 0) {
-
       if (all_blank)
-         all_blank = ch == ' ';
+         all_blank = ch == ' ' || (ch >= '\t' && ch <= '\r');
 
       if (all_shouty)
          all_shouty = !(ch >= 'a' && ch <= 'z');
@@ -32,6 +31,9 @@ char *hey_bob(char *greeting)
    if (all_blank)
       return "Fine. Be that way!";
 
+   if (all_shouty && any_letters && final_char == '?')
+      return "Calm down, I know what I'm doing!";
+
    if (any_letters && all_shouty)
       return "Whoa, chill out!";
 

data/tracks/c/exercises/bob/test/test_bob.c

@@ -22,6 +22,13 @@ void test_shouting(void)
        );
 }
 
+void test_shouting_gibberish(void)
+{
+   TEST_IGNORE();
+   TEST_ASSERT_EQUAL_STRING("Whoa, chill out!", hey_bob("FCECDFCAAB")
+       );
+}
+
 void test_asking_a_question(void)
 {
    TEST_IGNORE();
@@ -31,6 +38,20 @@ void test_asking_a_question(void)
        );
 }
 
+void test_asking_a_numeric_question(void)
+{
+   TEST_IGNORE();
+   TEST_ASSERT_EQUAL_STRING("Sure.", hey_bob("You are, what, like 15?")
+       );
+}
+
+void test_asking_gibberish(void)
+{
+   TEST_IGNORE();
+   TEST_ASSERT_EQUAL_STRING("Sure.", hey_bob("fffbbcbeab?")
+       );
+}
+
 void test_talking_forcefully(void)
 {
    TEST_IGNORE();
@@ -48,10 +69,10 @@ void test_using_acronyms_in_regular_speech(void)
        );
 }
 
-void test_forceful_questions(void)
+void test_forceful_question(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL_STRING("Whoa, chill out!",
+   TEST_ASSERT_EQUAL_STRING("Calm down, I know what I'm doing!",
                             hey_bob("WHAT THE HELL WERE YOU THINKING?")
        );
 }
@@ -101,18 +122,18 @@ void test_statement_containing_question_mark(void)
        );
 }
 
-void test_prattling_on(void)
+void test_non_letters_with_question(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL_STRING("Sure.",
-                            hey_bob("Wait! Hang on.  Are you going to be OK?")
+   TEST_ASSERT_EQUAL_STRING("Sure.", hey_bob(":) ?")
        );
 }
 
-void test_question_with_trailing_whitespace(void)
+void test_prattling_on(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL_STRING("Sure.", hey_bob("Are you ok? ")
+   TEST_ASSERT_EQUAL_STRING("Sure.",
+                            hey_bob("Wait! Hang on.  Are you going to be OK?")
        );
 }
 
@@ -130,11 +151,52 @@ void test_prolonged_silence(void)
        );
 }
 
-void test_not_all_silence(void)
+void test_alternate_silence(void)
+{
+   TEST_IGNORE();
+   TEST_ASSERT_EQUAL_STRING("Fine. Be that way!",
+                            hey_bob("\t\t\t\t\t\t\t\t\t\t")
+       );
+}
+
+void test_multiple_line_question(void)
+{
+   TEST_IGNORE();
+   TEST_ASSERT_EQUAL_STRING("Whatever.",
+                            hey_bob
+                            ("\nDoes this cryogenic chamber make me look fat?\nno")
+       );
+}
+
+void test_starting_with_whitespace(void)
+{
+   TEST_IGNORE();
+   TEST_ASSERT_EQUAL_STRING("Whatever.", hey_bob("         hmmmmmmm...")
+       );
+}
+
+void test_ending_with_whitespace(void)
+{
+   TEST_IGNORE();
+   TEST_ASSERT_EQUAL_STRING("Sure.",
+                            hey_bob
+                            ("Okay if like my  spacebar  quite a bit?   ")
+       );
+}
+
+void test_other_whitespace(void)
+{
+   TEST_IGNORE();
+   TEST_ASSERT_EQUAL_STRING("Fine. Be that way!", hey_bob("\n\r \t")
+       );
+}
+
+void test_non_question_ending_with_whitespace(void)
 {
    TEST_IGNORE();
    TEST_ASSERT_EQUAL_STRING("Whatever.",
-                            hey_bob(" A bit of silence can be nice.  ")
+                            hey_bob
+                            ("This is a statement ending with whitespace      ")
        );
 }
 
@@ -144,21 +206,29 @@ int main(void)
 
    RUN_TEST(test_stating_something);
    RUN_TEST(test_shouting);
+   RUN_TEST(test_shouting_gibberish);
    RUN_TEST(test_asking_a_question);
+   RUN_TEST(test_asking_a_numeric_question);
+   RUN_TEST(test_asking_gibberish);
    RUN_TEST(test_talking_forcefully);
    RUN_TEST(test_using_acronyms_in_regular_speech);
-   RUN_TEST(test_forceful_questions);
+   RUN_TEST(test_forceful_question);
    RUN_TEST(test_shouting_numbers);
    RUN_TEST(test_only_numbers);
    RUN_TEST(test_question_with_only_numbers);
    RUN_TEST(test_shouting_with_special_characters);
    RUN_TEST(test_shouting_with_no_exclamation_mark);
    RUN_TEST(test_statement_containing_question_mark);
+   RUN_TEST(test_non_letters_with_question);
    RUN_TEST(test_prattling_on);
-   RUN_TEST(test_question_with_trailing_whitespace);
    RUN_TEST(test_silence);
    RUN_TEST(test_prolonged_silence);
-   RUN_TEST(test_not_all_silence);
+   RUN_TEST(test_alternate_silence);
+   RUN_TEST(test_multiple_line_question);
+   RUN_TEST(test_starting_with_whitespace);
+   RUN_TEST(test_ending_with_whitespace);
+   RUN_TEST(test_other_whitespace);
+   RUN_TEST(test_non_question_ending_with_whitespace);
 
    UnityEnd();
    return 0;

data/tracks/c/exercises/palindrome-products/src/example.c

@@ -1,36 +1,109 @@
 #include "palindrome_products.h"
-#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <limits.h>
 
-/* Return true if the product of a and b is a palindrome, false otherwise */
-bool is_palindrome_product(int a, int b)
+static int palindrome(int n);
+static int addfactors(factor_t ** p, int i, int k);
+static void free_ll(struct factors *p);
+
+product_t *get_palindrome_product(int from, int to)
 {
-   int ret = 0, prod = a * b;
-   while (prod) {
-      ret *= 10;
-      ret += prod % 10;
-      prod /= 10;
+   product_t *res = malloc(sizeof(product_t));
+   if (res == NULL) {
+      fprintf(stderr, "Memory error!\n");
+      return NULL;
    }
-   return (a * b) == ret;
-}
 
-product_t get_palindrome_product(int min, int max)
-{
-   product_t ret;
-   ret.smallest = 0;
-   ret.largest = 0;
-   bool largest = false;
-
-   for (int i = min; i <= max; i++) {
-      for (int j = min; j <= max; j++) {
-         if (is_palindrome_product(i, j) == true) {
-            if (largest == false) {
-               ret.smallest = i * j;
-               largest = true;
-            } else {
-               ret.largest = i * j;
+   res->error[MAXERR - 1] = '\0';
+   res->smallest = INT_MAX;
+   res->largest = INT_MIN;
+   res->factors_lg = NULL;
+   res->factors_sm = NULL;
+
+   if (from > to) {
+      snprintf(res->error, MAXERR - 1,
+               "invalid input: min is %i and max is %i", from, to);
+      return res;
+   }
+
+   int i, k, n;
+   int err = 0;
+   for (i = from; i <= to; i++)
+      for (k = i; k <= to; k++)
+         if (palindrome(n = i * k)) {
+            if (n <= res->smallest) {
+               res->smallest = n;
+               err = addfactors(&res->factors_sm, i, k);
+            } else if (n >= res->largest) {
+               res->largest = n;
+               err = addfactors(&res->factors_lg, i, k);
+            }
+            if (err) {
+               free(res);
+               return NULL;
             }
          }
-      }
+
+   if ((res->smallest == INT_MAX) || (res->largest == INT_MIN)) {
+      snprintf(res->error, MAXERR - 1,
+               "no palindrome with factors in the range %i to %i", from, to);
+      return res;
    }
-   return ret;
+   return res;
+}
+
+void free_product(product_t * p)
+{
+   if (p == NULL)
+      return;
+   free_ll(p->factors_lg);
+   free_ll(p->factors_sm);
+   free(p);
+}
+
+static void free_ll(struct factors *p)
+{
+   if (p == NULL)
+      return;
+   if (p->next != NULL)
+      free_ll(p->next);
+   free(p);
+}
+
+static int addfactors(factor_t ** p, int i, int k)
+{
+   int n = i * k;
+   if ((*p == NULL) || (((*p)->factor_a) * (*p)->factor_b != n)) {
+      free_ll(*p);
+      *p = NULL;
+   }
+
+   factor_t *tmp = malloc(sizeof(factor_t));
+   if (tmp == NULL) {
+      fprintf(stderr, "Memory error!\n");
+      return 1;
+   }
+
+   tmp->next = *p;
+   tmp->factor_a = i;
+   tmp->factor_b = k;
+   *p = tmp;
+   return 0;
+}
+
+static int palindrome(int n)
+{
+   if (n < 0)
+      n *= -1;
+   int r = 0;
+   int nn = n;
+
+   /* inverse n in r */
+   while (n >= 1) {
+      r = (r * 10) + (n % 10);
+      n /= 10;
+   }
+
+   return (nn == r);
 }

data/tracks/c/exercises/palindrome-products/src/example.h

@@ -1,12 +1,27 @@
 #ifndef PALINDROME_PRODUCTS_H
 #define PALINDROME_PRODUCTS_H
 
-typedef struct {
+#define MAXERR 100
+
+struct factors {
+   int factor_a;
+   int factor_b;
+   struct factors *next;
+};
+
+typedef struct factors factor_t;
+
+struct product {
    int smallest;
    int largest;
-} product_t;
+   factor_t *factors_sm;
+   factor_t *factors_lg;
+   char error[MAXERR];
+};
+
+typedef struct product product_t;
 
-/* Return the smallest and largest palindrome products in the range of min and max */
-product_t get_palindrome_product(int min, int max);
+product_t *get_palindrome_product(int from, int to);
+void free_product(product_t * p);
 
 #endif

data/tracks/c/exercises/palindrome-products/test/test_palindrome_products.c

@@ -9,27 +9,195 @@ void tearDown(void)
 {
 }
 
-void test_palindromes_list(void)
+void check_factors(factor_t * actual, int depth, factor_t expected[])
 {
-   product_t product = get_palindrome_product(1, 9);
-   TEST_ASSERT_EQUAL_INT(1, product.smallest);
-   TEST_ASSERT_EQUAL_INT(9, product.largest);
+   if (depth == 0) {
+      TEST_ASSERT_EQUAL_PTR(NULL, actual);
+      return;
+   }
+   int i;
+   int count_ok = 0;
+   for (i = 0; i < depth; i++) {
+      if (actual == NULL)
+         break;
+      if ((actual->factor_a == expected[i].factor_a) &&
+          (actual->factor_b == expected[i].factor_b))
+         count_ok++;
+      actual = actual->next;
+   }
+   TEST_ASSERT_EQUAL_PTR(NULL, actual);
+   TEST_ASSERT_EQUAL_INT(depth, count_ok);
 }
 
-void test_palindromes_list2(void)
+void test_smallest_palindrome_from_single_digit_factors(void)
+{
+   product_t *product = get_palindrome_product(1, 9);
+   TEST_ASSERT_NOT_NULL(product);
+   TEST_ASSERT_EQUAL_INT(1, product->smallest);
+
+   factor_t expected_sm[] = { {1, 1, NULL} };
+   check_factors(product->factors_sm, 1, expected_sm);
+
+   free_product(product);
+}
+
+void test_largest_palindrome_from_single_digit_factors(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   product_t *product = get_palindrome_product(1, 9);
+   TEST_ASSERT_NOT_NULL(product);
+   TEST_ASSERT_EQUAL_INT(9, product->largest);
+
+   factor_t expected_lg[] = { {3, 3, NULL}, {1, 9, NULL} };
+   check_factors(product->factors_lg, 2, expected_lg);
+
+   free_product(product);
+}
+
+void test_smallest_palindrome_from_double_digit_factors(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   product_t *product = get_palindrome_product(10, 99);
+   TEST_ASSERT_NOT_NULL(product);
+   TEST_ASSERT_EQUAL_INT(121, product->smallest);
+
+   factor_t expected_sm[] = { {11, 11, NULL} };
+   check_factors(product->factors_sm, 1, expected_sm);
+
+   free_product(product);
+}
+
+void test_largest_palindrome_from_double_digit_factors(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   product_t *product = get_palindrome_product(10, 99);
+   TEST_ASSERT_NOT_NULL(product);
+   TEST_ASSERT_EQUAL_INT(9009, product->largest);
+
+   factor_t expected_lg[] = { {91, 99, NULL} };
+   check_factors(product->factors_lg, 1, expected_lg);
+
+   free_product(product);
+}
+
+void test_smallest_palindrome_from_triple_digit_factors(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   product_t *product = get_palindrome_product(100, 999);
+   TEST_ASSERT_NOT_NULL(product);
+   TEST_ASSERT_EQUAL_INT(10201, product->smallest);
+
+   factor_t expected_sm[] = { {101, 101, NULL} };
+   check_factors(product->factors_sm, 1, expected_sm);
+
+   free_product(product);
+}
+
+void test_largest_palindrome_from_triple_digit_factors(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   product_t *product = get_palindrome_product(100, 999);
+   TEST_ASSERT_NOT_NULL(product);
+   TEST_ASSERT_EQUAL_INT(906609, product->largest);
+
+   factor_t expected_lg[] = { {913, 993, NULL} };
+   check_factors(product->factors_lg, 1, expected_lg);
+
+   free_product(product);
+}
+
+void test_smallest_palindrome_from_four_digit_factors(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   product_t *product = get_palindrome_product(1000, 9999);
+   TEST_ASSERT_NOT_NULL(product);
+   TEST_ASSERT_EQUAL_INT(1002001, product->smallest);
+
+   factor_t expected_sm[] = { {1001, 1001, NULL} };
+   check_factors(product->factors_sm, 1, expected_sm);
+
+   free_product(product);
+}
+
+void test_largest_palindrome_from_four_digit_factors(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   product_t *product = get_palindrome_product(1000, 9999);
+   TEST_ASSERT_NOT_NULL(product);
+   TEST_ASSERT_EQUAL_INT(99000099, product->largest);
+
+   factor_t expected_lg[] = { {9901, 9999, NULL} };
+   check_factors(product->factors_lg, 1, expected_lg);
+
+   free_product(product);
+}
+
+void test_empty_result_for_smallest_if_no_palindrome_in_the_range(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   product_t *product = get_palindrome_product(1002, 1003);
+   TEST_ASSERT_NOT_NULL(product);
+   const char *expected =
+       "no palindrome with factors in the range 1002 to 1003";
+   TEST_ASSERT_EQUAL_STRING(expected, product->error);
+
+   free_product(product);
+}
+
+void test_empty_result_for_largest_if_no_palindrome_in_the_range(void)
 {
    TEST_IGNORE();               // delete this line to run test
-   product_t product = get_palindrome_product(10, 99);
-   TEST_ASSERT_EQUAL_INT(121, product.smallest);
-   TEST_ASSERT_EQUAL_INT(9009, product.largest);
+   product_t *product = get_palindrome_product(15, 15);
+   TEST_ASSERT_NOT_NULL(product);
+   const char *expected = "no palindrome with factors in the range 15 to 15";
+   TEST_ASSERT_EQUAL_STRING(expected, product->error);
+
+   free_product(product);
+}
+
+void test_error_result_for_smallest_if_min_is_more_than_max(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   product_t *product = get_palindrome_product(10000, 1);
+   TEST_ASSERT_NOT_NULL(product);
+   const char *expected = "invalid input: min is 10000 and max is 1";
+   TEST_ASSERT_EQUAL_STRING(expected, product->error);
+
+   free_product(product);
+}
+
+void test_error_result_for_largest_if_min_is_more_than_max(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   product_t *product = get_palindrome_product(2, 1);
+   TEST_ASSERT_NOT_NULL(product);
+   const char *expected = "invalid input: min is 2 and max is 1";
+   TEST_ASSERT_EQUAL_STRING(expected, product->error);
+
+   free_product(product);
 }
 
 int main(void)
 {
    UnityBegin("test/test_palindrome_products.c");
 
-   RUN_TEST(test_palindromes_list);
-   RUN_TEST(test_palindromes_list2);
+   RUN_TEST(test_smallest_palindrome_from_single_digit_factors);
+   RUN_TEST(test_largest_palindrome_from_single_digit_factors);
+
+   RUN_TEST(test_smallest_palindrome_from_double_digit_factors);
+   RUN_TEST(test_largest_palindrome_from_double_digit_factors);
+
+   RUN_TEST(test_smallest_palindrome_from_triple_digit_factors);
+   RUN_TEST(test_largest_palindrome_from_triple_digit_factors);
+
+   RUN_TEST(test_smallest_palindrome_from_four_digit_factors);
+   RUN_TEST(test_largest_palindrome_from_four_digit_factors);
+
+   RUN_TEST(test_empty_result_for_smallest_if_no_palindrome_in_the_range);
+   RUN_TEST(test_empty_result_for_largest_if_no_palindrome_in_the_range);
+
+   RUN_TEST(test_error_result_for_smallest_if_min_is_more_than_max);
+   RUN_TEST(test_error_result_for_largest_if_min_is_more_than_max);
 
    UnityEnd();
    return 0;

data/tracks/common-lisp/exercises/bob/README.md

@@ -6,6 +6,8 @@ Bob answers 'Sure.' if you ask him a question.
 
 He answers 'Whoa, chill out!' if you yell at him.
 
+He answers 'Calm down, I know what I'm doing!' if you yell a question at him.
+
 He says 'Fine. Be that way!' if you address him without actually saying
 anything.
 

data/tracks/common-lisp/exercises/bob/bob-test.lisp

@@ -12,9 +12,18 @@
 (define-test responds-to-shouts
   (assert-equal "Whoa, chill out!" (bob:response-for "WATCH OUT!")))
 
+(define-test shouting-gibberish
+  (assert-equal "Whoa, chill out!" (bob:response-for "FCECDFCAAB")))
+
 (define-test responds-to-questions
   (assert-equal "Sure." (bob:response-for "Does this cryogenic chamber make me look fat?")))
 
+(define-test asking-a-numeric-question
+  (assert-equal "Sure." (bob:response-for "You are, what, like 15?")))
+
+(define-test asking-gibberish
+  (assert-equal "Sure." (bob:response-for "fffbbcbeab?")))
+
 (define-test responds-to-forceful-talking
   (assert-equal "Whatever." (bob:response-for "Let's go make out behind the gym!")))
 
@@ -22,31 +31,59 @@
   (assert-equal "Whatever." (bob:response-for "It's OK if you don't want to go to the DMV.")))
 
 (define-test responds-to-forceful-questions
-  (assert-equal "Whoa, chill out!" (bob:response-for "WHAT THE HELL WERE YOU THINKING?")))
-
-(define-test responds-to-shouting-with-special-characters
-  (assert-equal "Whoa, chill out!" (bob:response-for "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!")))
+  (assert-equal "Calm down, I know what I'm doing!"
+                (bob:response-for "WHAT THE HELL WERE YOU THINKING?")))
 
 (define-test responds-to-shouting-numbers
   (assert-equal "Whoa, chill out!" (bob:response-for "1, 2, 3 GO!")))
 
+(define-test responds-to-only-numbers
+  (assert-equal "Whatever." (bob:response-for "1, 2, 3")))
+
+(define-test responds-to-number-question
+  (assert-equal "Sure." (bob:response-for "4?")))
+
+(define-test responds-to-shouting-with-special-characters
+  (assert-equal "Whoa, chill out!" (bob:response-for "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!")))
+
 (define-test responds-to-shouting-with-no-exclamation-mark
   (assert-equal "Whoa, chill out!" (bob:response-for "I HATE YOU")))
 
 (define-test responds-to-statement-containing-question-mark
   (assert-equal "Whatever." (bob:response-for "Ending with ? means a question.")))
 
+(define-test non-letters-with-question
+  (assert-equal "Sure." (bob:response-for ":) ?")))
+
+(define-test prattling-ton
+  (assert-equal "Sure." (bob:response-for "Wait! Hang on. Are you going to be OK?")))
+
 (define-test responds-to-silence
   (assert-equal "Fine. Be that way!" (bob:response-for "")))
 
 (define-test responds-to-prolonged-silence
   (assert-equal "Fine. Be that way!" (bob:response-for "    ")))
 
-(define-test responds-to-only-numbers
-  (assert-equal "Whatever." (bob:response-for "1, 2, 3")))
+(define-test responds-to-alternate-silence
+  (assert-equal "Fine. Be that way!"
+                (bob:response-for (coerce (list #\Tab #\Tab #\Tab #\Tab) 'string))))
 
-(define-test responds-to-number-question
-  (assert-equal "Sure." (bob:response-for "4?")))
+(define-test respond-to-multiline-question
+  (assert-equal "Whatever."
+                (bob:response-for (format nil "~%Does this cryogenic chamber make me look fat?~%no"))))
+
+(define-test starting-with-whitespace
+  (assert-equal "Whatever." (bob:response-for "         hmmmmmmm...")))
+
+(define-test ending-with-whitespace
+  (assert-equal "Sure." (bob:response-for "Okay if like my  spacebar  quite a bit?   ")))
+
+(define-test other-whitespace
+  (assert-equal "Fine. Be that way!"
+                (bob:response-for (coerce (list #\Newline #\Tab #\Page) 'string))))
+
+(define-test non-question-ending-with-whitespace
+  (assert-equal "Whatever." (bob:response-for "This is a statement ending with whitespace      ")))
 
 #-xlisp-test
 (let ((*print-errors* t)