diff --git a/includes/math-expr.inc b/includes/math-expr.inc
index 3105ec5..4b13a67 100644
--- a/includes/math-expr.inc
+++ b/includes/math-expr.inc
@@ -81,308 +81,562 @@
     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     POSSIBILITY OF SUCH DAMAGE.
-
 */
 
 class ctools_math_expr {
-    var $suppress_errors = false;
-    var $last_error = null;
-
-    var $v = array('e'=>2.71,'pi'=>3.14); // variables (and constants)
-    var $f = array(); // user-defined functions
-    var $vb = array('e', 'pi'); // constants
-    var $fb = array(  // built-in functions
-        'sin','sinh','arcsin','asin','arcsinh','asinh',
-        'cos','cosh','arccos','acos','arccosh','acosh',
-        'tan','tanh','arctan','atan','arctanh','atanh',
-        'pow', 'exp',
-        'sqrt','abs','ln','log',
-        'time', 'ceil', 'floor', 'min', 'max', 'round');
-
-    function __construct() {
-        // make the variables a little more accurate
-        $this->v['pi'] = pi();
-        $this->v['e'] = exp(1);
-        drupal_alter('ctools_math_expression_functions', $this->fb);
-    }
+  var $suppress_errors = FALSE;
+  var $last_error = NULL;
+  var $errors = array();
+
+  var $v = array('e' => 2.71, 'pi' => 3.14); // variables (and constants)
+  var $f = array(); // user-defined functions
+  var $vb = array('e', 'pi'); // constants
+  var $fsimple = array( // built-in functions
+    'sin', 'sinh', 'asin', 'asinh',
+    'cos', 'cosh', 'acos', 'acosh',
+    'tan', 'tanh', 'atan', 'atanh',
+    'exp',
+    'sqrt', 'abs', 'log',
+    'time', 'ceil', 'floor', 'round'
+  );
+  var $fb = array(
+    'ln' => array(
+      'function' => 'log',
+      'arguments' => 1,
+    ),
+    'arcsin' => array(
+      'function' => 'asin',
+      'arguments' => 1,
+    ),
+    'arcsinh' => array(
+      'function' => 'asinh',
+      'arguments' => 1,
+    ),
+    'arccos' => array(
+      'function' => 'acos',
+      'arguments' => 1,
+    ),
+    'arccosh' => array(
+      'function' => 'acosh',
+      'arguments' => 1,
+    ),
+    'arctan' => array(
+      'function' => 'atan',
+      'arguments' => 1,
+    ),
+    'arctanh' => array(
+      'function' => 'atanh',
+      'arguments' => 1,
+    ),
+    'min' => array(
+      'function' => 'min',
+      'arguments' => 2,
+      'max arguments' => 99,
+    ),
+    'max' => array(
+      'function' => 'max',
+      'arguments' => 2,
+      'max arguments' => 99,
+    ),
+    'pow' => array(
+      'function' => 'pow',
+      'arguments' => 2,
+    ),
+    'if' => array(
+      'function' => 'ctools_math_expr_if',
+      'arguments' => 2,
+      'max arguments' => 3,
+    ),
+    'number' => array(
+      'function' => 'ctools_math_expr_number',
+      'arguments' => 1,
+    ),
+  );
+
+  /**
+   * Public constructor.
+   */
+  public function __construct() {
+    // Make the variables a little more accurate.
+    $this->v['pi'] = pi();
+    $this->v['e'] = exp(1);
+
+    // Allow modules to add custom functions.
+    // @todo -- properly document this.
+    $context = array('final' => &$this->fb);
+    drupal_alter('ctools_math_expression_functions', $this->fsimple, $context);
 
-    function e($expr) {
-        return $this->evaluate($expr);
+    // Translate the older, simpler style into the newer, richer style.
+    foreach ($this->fsimple as $function) {
+      $this->fb[$function] = array(
+        'function' => $function,
+        'arguments' => 1,
+      );
     }
+  }
 
-    function evaluate($expr) {
-        $this->last_error = null;
-        $expr = trim($expr);
-        if (substr($expr, -1, 1) == ';') $expr = substr($expr, 0, strlen($expr)-1); // strip semicolons at the end
-        //===============
-        // is it a variable assignment?
-        if (preg_match('/^\s*([a-z]\w*)\s*=\s*(.+)$/', $expr, $matches)) {
-            if (in_array($matches[1], $this->vb)) { // make sure we're not assigning to a constant
-                return $this->trigger("cannot assign to constant '$matches[1]'");
-            }
-            if (($tmp = $this->pfx($this->nfx($matches[2]))) === false) return false; // get the result and make sure it's good
-            $this->v[$matches[1]] = $tmp; // if so, stick it in the variable array
-            return $this->v[$matches[1]]; // and return the resulting value
-        //===============
-        // is it a function assignment?
-        } elseif (preg_match('/^\s*([a-z]\w*)\s*\(\s*([a-z]\w*(?:\s*,\s*[a-z]\w*)*)\s*\)\s*=\s*(.+)$/', $expr, $matches)) {
-            $fnn = $matches[1]; // get the function name
-            if (in_array($matches[1], $this->fb)) { // make sure it isn't built in
-                return $this->trigger("cannot redefine built-in function '$matches[1]()'");
-            }
-            $args = explode(",", preg_replace("/\s+/", "", $matches[2])); // get the arguments
-            if (($stack = $this->nfx($matches[3])) === false) return false; // see if it can be converted to postfix
-            for ($i = 0; $i<count($stack); $i++) { // freeze the state of the non-argument variables
-                $token = $stack[$i];
-                if (preg_match('/^[a-z]\w*$/', $token) and !in_array($token, $args)) {
-                    if (array_key_exists($token, $this->v)) {
-                        $stack[$i] = $this->v[$token];
-                    } else {
-                        return $this->trigger("undefined variable '$token' in function definition");
-                    }
-                }
-            }
-            $this->f[$fnn] = array('args'=>$args, 'func'=>$stack);
-            return true;
-        //===============
-        } else {
-            return $this->pfx($this->nfx($expr)); // straight up evaluation, woo
-        }
+  /**
+   * Backwards compatible wrapper for evaluate().
+   */
+  function e($expr) {
+    return evaluate($expr);
+  }
+
+  /**
+   * Evaluate the expression.
+   *
+   * @param string $expr The expression to evaluate.
+   * @return string
+   */
+  function evaluate($expr) {
+    $this->last_error = NULL;
+    $expr = trim($expr);
+    if (substr($expr, -1, 1) == ';') {
+      $expr = substr($expr, 0, strlen($expr) - 1);
+    } // strip semicolons at the end
+
+    // is it a variable assignment?
+    if (preg_match('/^\s*([a-z]\w*)\s*=\s*(.+)$/', $expr, $matches)) {
+      if (in_array($matches[1], $this->vb)) { // make sure we're not assigning to a constant
+        return $this->trigger("cannot assign to constant '$matches[1]'");
+      }
+      if (($tmp = $this->pfx($this->nfx($matches[2]))) === FALSE) {
+        return FALSE;
+      } // get the result and make sure it's good
+      $this->v[$matches[1]] = $tmp; // if so, stick it in the variable array
+      return $this->v[$matches[1]]; // and return the resulting value
+
+      // is it a function assignment?
     }
+    elseif (preg_match('/^\s*([a-z]\w*)\s*\(\s*([a-z]\w*(?:\s*,\s*[a-z]\w*)*)\s*\)\s*=\s*(.+)$/', $expr, $matches)) {
+      $fnn = $matches[1]; // get the function name
+      if (isset($this->fb[$matches[1]])) { // make sure it isn't built in
+        return $this->trigger("cannot redefine built-in function '$matches[1]()'");
+      }
+      $args = explode(",", preg_replace("/\s+/", "", $matches[2])); // get the arguments
+      if (($stack = $this->nfx($matches[3])) === FALSE) {
+        return FALSE;
+      } // see if it can be converted to postfix
+      for ($i = 0; $i < count($stack); $i++) { // freeze the state of the non-argument variables
+        $token = $stack[$i];
+        if (preg_match('/^[a-z]\w*$/', $token) and !in_array($token, $args)) {
+          if (array_key_exists($token, $this->v)) {
+            $stack[$i] = $this->v[$token];
+          }
+          else {
+            return $this->trigger("undefined variable '$token' in function definition");
+          }
+        }
+      }
+      $this->f[$fnn] = array('args' => $args, 'func' => $stack);
+
+      return TRUE;
 
-    function vars() {
-        $output = $this->v;
-        unset($output['pi']);
-        unset($output['e']);
-        return $output;
     }
+    else {
+      return trim($this->pfx($this->nfx($expr)), '"'); // straight up evaluation, woo
+    }
+  }
+
+  /**
+   * Fetch an array of variables used in the expression.
+   *
+   * @return array
+   */
+  public function vars() {
+    $output = $this->v;
+    unset($output['pi']);
+    unset($output['e']);
 
-    function funcs() {
-        $output = array();
-        foreach ($this->f as $fnn=>$dat)
-            $output[] = $fnn . '(' . implode(',', $dat['args']) . ')';
-        return $output;
+    return $output;
+  }
+
+  /**
+   * Fetch all user defined functions in the expression.
+   *
+   * @return array
+   */
+  public function funcs() {
+    $output = array();
+    foreach ($this->f as $fnn => $dat) {
+      $output[] = $fnn . '(' . implode(',', $dat['args']) . ')';
     }
 
-    //===================== HERE BE INTERNAL METHODS ====================\\
+    return $output;
+  }
+
+  // Convert infix to postfix notation
+  private function nfx($expr) {
 
-    // Convert infix to postfix notation
-    function nfx($expr) {
+    $index = 0;
+    $stack = new ctools_math_expr_stack;
+    $output = array(); // postfix form of expression, to be passed to pfx()
+    $expr = trim(strtolower($expr));
 
-        $index = 0;
-        $stack = new ctools_math_expr_stack;
-        $output = array(); // postfix form of expression, to be passed to pfx()
-        $expr = trim(strtolower($expr));
+    $ops = array(
+      '+' => array(
+        'precedence' => 0,
+      ),
+      '-' => array(
+        'precedence' => 0,
+      ),
+      '*'=> array(
+        'precedence' => 1,
+      ),
+      '/'=> array(
+        'precedence' => 1,
+      ),
+      '^' => array(
+        'right' => TRUE,
+        'precedence' => 2,
+      ),
+      '_' => array(
+        'precedence' => 1,
+      ),
+      '==' => array(
+        'precedence' => -1,
+      ),
+      '!=' => array(
+        'precedence' => -1,
+      ),
+      '>=' => array(
+        'precedence' => -1,
+      ),
+      '<=' => array(
+        'precedence' => -1,
+      ),
+      '>' => array(
+        'precedence' => -1,
+      ),
+      '<' => array(
+        'precedence' => -1,
+      )
+    );
+    $expecting_op = FALSE; // we use this in syntax-checking the expression
+    // And determining when a - is a negation
 
-        $ops   = array('+', '-', '*', '/', '^', '_');
-        $ops_r = array('+'=>0,'-'=>0,'*'=>0,'/'=>0,'^'=>1); // right-associative operator?
-        $ops_p = array('+'=>0,'-'=>0,'*'=>1,'/'=>1,'_'=>1,'^'=>2); // operator precedence
+    while (1) { // 1 Infinite Loop ;)
+      $op = substr($expr, $index, 1); // get the first character at the current index
+      // if the second character is an =, add it to our op.
+      if (substr($expr, $index + 1, 1) == '=') {
+        $op = substr($expr, $index, 2);
+        $index++;
+      }
+      // find out if we're currently at the beginning of a number/variable/function/parenthesis/operand
+      $ex = preg_match('/^([a-z]\w*\(?|\d+(?:\.\d*)?|\.\d+|\()/', substr($expr, $index), $match);
 
-        $expecting_op = false; // we use this in syntax-checking the expression
-                               // and determining when a - is a negation
+      if ($op == '-' and !$expecting_op) { // is it a negation instead of a minus?
+        $stack->push('_'); // put a negation on the stack
+        $index++;
+      }
+      elseif ($op == '_') { // we have to explicitly deny this, because it's legal on the stack
+        return $this->trigger("illegal character '_'"); // but not in the input expression
 
-        if (preg_match("/[^\w\s+*^\/()\.,-]/", $expr, $matches)) { // make sure the characters are all good
-            return $this->trigger("illegal character '{$matches[0]}'");
+      }
+      elseif ((isset($ops[$op]) || $ex) && $expecting_op) { // are we putting an operator on the stack?
+        if ($ex) { // are we expecting an operator but have a number/variable/function/opening parenthesis?
+          $op = '*';
+          $index--; // it's an implicit multiplication
         }
+        // heart of the algorithm:
+        while ($stack->count > 0 && ($o2 = $stack->last()) && isset($ops[$o2]) && (!empty($ops[$op]['right']) ? $ops[$op]['precedence'] < $ops[$o2]['precedence'] : $ops[$op]['precedence'] <= $ops[$o2]['precedence'])) {
+          $output[] = $stack->pop(); // pop stuff off the stack into the output
+        }
+        // many thanks: http://en.wikipedia.org/wiki/Reverse_Polish_notation#The_algorithm_in_detail
+        $stack->push($op); // finally put OUR operator onto the stack
+        $index++;
+        $expecting_op = FALSE;
 
-        while(1) { // 1 Infinite Loop ;)
-            $op = substr($expr, $index, 1); // get the first character at the current index
-            // find out if we're currently at the beginning of a number/variable/function/parenthesis/operand
-            $ex = preg_match('/^([a-z]\w*\(?|\d+(?:\.\d*)?|\.\d+|\()/', substr($expr, $index), $match);
-            //===============
-            if ($op == '-' and !$expecting_op) { // is it a negation instead of a minus?
-                $stack->push('_'); // put a negation on the stack
-                $index++;
-            } elseif ($op == '_') { // we have to explicitly deny this, because it's legal on the stack
-                return $this->trigger("illegal character '_'"); // but not in the input expression
-            //===============
-            } elseif ((in_array($op, $ops) or $ex) and $expecting_op) { // are we putting an operator on the stack?
-                if ($ex) { // are we expecting an operator but have a number/variable/function/opening parethesis?
-                    $op = '*'; $index--; // it's an implicit multiplication
-                }
-                // heart of the algorithm:
-                while($stack->count > 0 and ($o2 = $stack->last()) and in_array($o2, $ops) and ($ops_r[$op] ? $ops_p[$op] < $ops_p[$o2] : $ops_p[$op] <= $ops_p[$o2])) {
-                    $output[] = $stack->pop(); // pop stuff off the stack into the output
-                }
-                // many thanks: http://en.wikipedia.org/wiki/Reverse_Polish_notation#The_algorithm_in_detail
-                $stack->push($op); // finally put OUR operator onto the stack
-                $index++;
-                $expecting_op = false;
-            //===============
-            } elseif ($op == ')' and $expecting_op) { // ready to close a parenthesis?
-                while (($o2 = $stack->pop()) != '(') { // pop off the stack back to the last (
-                    if (is_null($o2)) return $this->trigger("unexpected ')'");
-                    else $output[] = $o2;
-                }
-                if (preg_match("/^([a-z]\w*)\($/", $stack->last(2), $matches)) { // did we just close a function?
-                    $fnn = $matches[1]; // get the function name
-                    $arg_count = $stack->pop(); // see how many arguments there were (cleverly stored on the stack, thank you)
-                    $output[] = $stack->pop(); // pop the function and push onto the output
-                    if (in_array($fnn, $this->fb)) { // check the argument count
-                        if($arg_count > 1)
-                            return $this->trigger("too many arguments ($arg_count given, 1 expected)");
-                    } elseif (array_key_exists($fnn, $this->f)) {
-                        if ($arg_count != count($this->f[$fnn]['args']))
-                            return $this->trigger("wrong number of arguments ($arg_count given, " . count($this->f[$fnn]['args']) . " expected)");
-                    } else { // did we somehow push a non-function on the stack? this should never happen
-                        return $this->trigger("internal error");
-                    }
-                }
-                $index++;
-            //===============
-            } elseif ($op == ',' and $expecting_op) { // did we just finish a function argument?
-                while (($o2 = $stack->pop()) != '(') {
-                    if (is_null($o2)) return $this->trigger("unexpected ','"); // oops, never had a (
-                    else $output[] = $o2; // pop the argument expression stuff and push onto the output
-                }
-                // make sure there was a function
-                if (!preg_match("/^([a-z]\w*)\($/", $stack->last(2), $matches))
-                    return $this->trigger("unexpected ','");
-                $stack->push($stack->pop()+1); // increment the argument count
-                $stack->push('('); // put the ( back on, we'll need to pop back to it again
-                $index++;
-                $expecting_op = false;
-            //===============
-            } elseif ($op == '(' and !$expecting_op) {
-                $stack->push('('); // that was easy
-                $index++;
-                $allow_neg = true;
-            //===============
-            } elseif ($ex and !$expecting_op) { // do we now have a function/variable/number?
-                $expecting_op = true;
-                $val = $match[1];
-                if (preg_match("/^([a-z]\w*)\($/", $val, $matches)) { // may be func, or variable w/ implicit multiplication against parentheses...
-                    if (in_array($matches[1], $this->fb) or array_key_exists($matches[1], $this->f)) { // it's a func
-                        $stack->push($val);
-                        $stack->push(1);
-                        $stack->push('(');
-                        $expecting_op = false;
-                    } else { // it's a var w/ implicit multiplication
-                        $val = $matches[1];
-                        $output[] = $val;
-                    }
-                } else { // it's a plain old var or num
-                    $output[] = $val;
-                }
-                $index += strlen($val);
-            //===============
-            } elseif ($op == ')') { // miscellaneous error checking
-                return $this->trigger("unexpected ')'");
-            } elseif (in_array($op, $ops) and !$expecting_op) {
-                return $this->trigger("unexpected operator '$op'");
-            } else { // I don't even want to know what you did to get here
-                return $this->trigger("an unexpected error occurred");
-            }
-            if ($index == strlen($expr)) {
-                if (in_array($op, $ops)) { // did we end with an operator? bad.
-                    return $this->trigger("operator '$op' lacks operand");
-                } else {
-                    break;
-                }
+      }
+      elseif ($op == ')' and $expecting_op) { // ready to close a parenthesis?
+        while (($o2 = $stack->pop()) != '(') { // pop off the stack back to the last (
+          if (is_null($o2)) {
+            return $this->trigger("unexpected ')'");
+          }
+          else {
+            $output[] = $o2;
+          }
+        }
+        if (preg_match("/^([a-z]\w*)\($/", $stack->last(2), $matches)) { // did we just close a function?
+          $fnn = $matches[1]; // get the function name
+          $arg_count = $stack->pop(); // see how many arguments there were (cleverly stored on the stack, thank you)
+          $output[] = $stack->pop(); // pop the function and push onto the output
+          if (isset($this->fb[$fnn])) { // check the argument count
+            $max_arguments = isset($this->fb[$fnn]['max arguments']) ? $this->fb[$fnn]['max arguments'] : $this->fb[$fnn]['arguments'];
+            if ($arg_count > $max_arguments) {
+              return $this->trigger("too many arguments ($arg_count given, $max_arguments expected)");
             }
-            while (substr($expr, $index, 1) == ' ') { // step the index past whitespace (pretty much turns whitespace
-                $index++;                             // into implicit multiplication if no operator is there)
+          }
+          elseif (array_key_exists($fnn, $this->f)) {
+            if ($arg_count != count($this->f[$fnn]['args'])) {
+              return $this->trigger("wrong number of arguments ($arg_count given, " . count($this->f[$fnn]['args']) . " expected)");
             }
+          }
+          else { // did we somehow push a non-function on the stack? this should never happen
+            return $this->trigger("internal error");
+          }
+        }
+        $index++;
+
+      }
+      elseif ($op == ',' and $expecting_op) { // did we just finish a function argument?
+        while (($o2 = $stack->pop()) != '(') {
+          if (is_null($o2)) {
+            return $this->trigger("unexpected ',' in $expr $o2");
+          } // oops, never had a (
+          else {
+            $output[] = $o2;
+          } // pop the argument expression stuff and push onto the output
+        }
+        // make sure there was a function
+        if (!preg_match("/^([a-z]\w*)\($/", $stack->last(2), $matches)) {
+          return $this->trigger("unexpected ','");
+        }
+        $stack->push($stack->pop() + 1); // increment the argument count
+        $stack->push('('); // put the ( back on, we'll need to pop back to it again
+        $index++;
+        $expecting_op = FALSE;
+
+      }
+      elseif ($op == '(' and !$expecting_op) {
+        $stack->push('('); // that was easy
+        $index++;
+        $allow_neg = TRUE;
 
+      }
+      elseif ($ex and !$expecting_op) { // do we now have a function/variable/number?
+        $expecting_op = TRUE;
+        $val = $match[1];
+        if (preg_match("/^([a-z]\w*)\($/", $val, $matches)) { // may be func, or variable w/ implicit multiplication against parentheses...
+          if (isset($this->fb[$matches[1]]) or array_key_exists($matches[1], $this->f)) { // it's a func
+            $stack->push($val);
+            $stack->push(1);
+            $stack->push('(');
+            $expecting_op = FALSE;
+          }
+          else { // it's a var w/ implicit multiplication
+            $val = $matches[1];
+            $output[] = $val;
+          }
         }
-        while (!is_null($op = $stack->pop())) { // pop everything off the stack and push onto output
-            if ($op == '(') return $this->trigger("expecting ')'"); // if there are (s on the stack, ()s were unbalanced
-            $output[] = $op;
+        else { // it's a plain old var or num
+          $output[] = $val;
         }
-        return $output;
+        $index += strlen($val);
+
+      }
+      elseif ($op == ')') { // miscellaneous error checking
+        return $this->trigger("unexpected ')'");
+      }
+      elseif (isset($ops[$op]) and !$expecting_op) {
+        return $this->trigger("unexpected operator '$op'");
+      }
+      elseif ($op == '"') {
+        // fetch a quoted string.
+        $string = substr($expr, $index);
+        if (preg_match('/"[^"\\\\]*(?:\\\\.[^"\\\\]*)*"/s', $string, $matches)) {
+          $string = $matches[0];
+          // trim the quotes off:
+          $output[] = $string;
+          $index += strlen($string);
+          $expecting_op = TRUE;
+        }
+        else {
+          return $this->trigger("open quote without close quote.");
+        }
+      }
+      else { // I don't even want to know what you did to get here
+        return $this->trigger("an unexpected error occurred at $op");
+      }
+      if ($index == strlen($expr)) {
+        if (isset($ops[$op])) { // did we end with an operator? bad.
+          return $this->trigger("operator '$op' lacks operand");
+        }
+        else {
+          break;
+        }
+      }
+      while (substr($expr, $index, 1) == ' ') { // step the index past whitespace (pretty much turns whitespace
+        $index++; // into implicit multiplication if no operator is there)
+      }
     }
+    while (!is_null($op = $stack->pop())) { // pop everything off the stack and push onto output
+      if ($op == '(') {
+        return $this->trigger("expecting ')'");
+      } // if there are (s on the stack, ()s were unbalanced
+      $output[] = $op;
+    }
+
+    return $output;
+  }
+
+  // evaluate postfix notation
+  function pfx($tokens, $vars = array()) {
 
-    // evaluate postfix notation
-    function pfx($tokens, $vars = array()) {
-
-        if ($tokens == false) return false;
-
-        $stack = new ctools_math_expr_stack;
-
-        foreach ($tokens as $token) { // nice and easy
-            // if the token is a binary operator, pop two values off the stack, do the operation, and push the result back on
-            if (in_array($token, array('+', '-', '*', '/', '^'))) {
-                if (is_null($op2 = $stack->pop())) return $this->trigger("internal error");
-                if (is_null($op1 = $stack->pop())) return $this->trigger("internal error");
-                switch ($token) {
-                    case '+':
-                        $stack->push($op1+$op2); break;
-                    case '-':
-                        $stack->push($op1-$op2); break;
-                    case '*':
-                        $stack->push($op1*$op2); break;
-                    case '/':
-                        if ($op2 == 0) return $this->trigger("division by zero");
-                        $stack->push($op1/$op2); break;
-                    case '^':
-                        $stack->push(pow($op1, $op2)); break;
-                }
-            // if the token is a unary operator, pop one value off the stack, do the operation, and push it back on
-            } elseif ($token == "_") {
-                $stack->push(-1*$stack->pop());
-            // if the token is a function, pop arguments off the stack, hand them to the function, and push the result back on
-            } elseif (preg_match("/^([a-z]\w*)\($/", $token, $matches)) { // it's a function!
-                $fnn = $matches[1];
-                if (in_array($fnn, $this->fb)) { // built-in function:
-                    if (is_null($op1 = $stack->pop())) return $this->trigger("internal error");
-                    $fnn = preg_replace("/^arc/", "a", $fnn); // for the 'arc' trig synonyms
-                    if ($fnn == 'ln') $fnn = 'log';
-                    eval('$stack->push(' . $fnn . '($op1));'); // perfectly safe eval()
-                } elseif (array_key_exists($fnn, $this->f)) { // user function
-                    // get args
-                    $args = array();
-                    for ($i = count($this->f[$fnn]['args'])-1; $i >= 0; $i--) {
-                        if (is_null($args[$this->f[$fnn]['args'][$i]] = $stack->pop())) return $this->trigger("internal error");
-                    }
-                    $stack->push($this->pfx($this->f[$fnn]['func'], $args)); // yay... recursion!!!!
-                }
-            // if the token is a number or variable, push it on the stack
-            } else {
-                if (is_numeric($token)) {
-                    $stack->push($token);
-                } elseif (array_key_exists($token, $this->v)) {
-                    $stack->push($this->v[$token]);
-                } elseif (array_key_exists($token, $vars)) {
-                    $stack->push($vars[$token]);
-                } else {
-                    return $this->trigger("undefined variable '$token'");
-                }
+    if ($tokens == FALSE) {
+      return FALSE;
+    }
+
+    $stack = new ctools_math_expr_stack;
+
+    foreach ($tokens as $token) { // nice and easy
+      // if the token is a binary operator, pop two values off the stack, do the operation, and push the result back on
+      if (in_array($token, array('+', '-', '*', '/', '^', '==', '!=', '<', '<=', '>=', '>'))) {
+        if (is_null($op2 = $stack->pop())) {
+          return $this->trigger("internal error");
+        }
+        if (is_null($op1 = $stack->pop())) {
+          return $this->trigger("internal error");
+        }
+        switch ($token) {
+          case '+':
+            $stack->push($op1 + $op2);
+            break;
+          case '-':
+            $stack->push($op1 - $op2);
+            break;
+          case '*':
+            $stack->push($op1 * $op2);
+            break;
+          case '/':
+            if ($op2 == 0) {
+              return $this->trigger("division by zero");
             }
+            $stack->push($op1 / $op2);
+            break;
+          case '^':
+            $stack->push(pow($op1, $op2));
+            break;
+          case '==':
+            $stack->push(intval($op1 == $op2));
+            break;
+          case '!=':
+            $stack->push(intval($op1 != $op2));
+            break;
+          case '<=':
+            $stack->push(intval($op1 <= $op2));
+            break;
+          case '<':
+            $stack->push(intval($op1 < $op2));
+            break;
+          case '>=':
+            $stack->push(intval($op1 >= $op2));
+            break;
+          case '>':
+            $stack->push(intval($op1 > $op2));
+            break;
         }
-        // when we're out of tokens, the stack should have a single element, the final result
-        if ($stack->count != 1) return $this->trigger("internal error");
-        return $stack->pop();
+        // if the token is a unary operator, pop one value off the stack, do the operation, and push it back on
+      }
+      elseif ($token == "_") {
+        $stack->push(-1 * $stack->pop());
+        // if the token is a function, pop arguments off the stack, hand them to the function, and push the result back on
+      }
+      elseif (preg_match("/^([a-z]\w*)\($/", $token, $matches)) { // it's a function!
+        $fnn = $matches[1];
+        if (isset($this->fb[$fnn])) { // built-in function:
+          $args = array();
+          for ($i = 0; $i < $this->fb[$fnn]['arguments']; $i++) {
+            if (is_null($op1 = $stack->pop())) {
+              return $this->trigger("function $fnn missing argument $i");
+            }
+            $args[] = $op1;
+          }
+          if (!empty($this->fb[$fnn]['max arguments'])) {
+            for(;$i < $this->fb[$fnn]['max arguments']; $i++) {
+              $arg = $stack->pop();
+              if (!isset($arg)) {
+                break;
+              }
+              $args[] = $arg;
+            }
+          }
+
+          $stack->push(call_user_func_array($this->fb[$fnn]['function'], array_reverse($args)));
+        }
+        elseif (isset($fnn, $this->f)) { // user function
+          // get args
+          $args = array();
+          for ($i = count($this->f[$fnn]['args']) - 1; $i >= 0; $i--) {
+            if (is_null($args[$this->f[$fnn]['args'][$i]] = $stack->pop())) {
+              return $this->trigger("internal error");
+            }
+          }
+          $stack->push($this->pfx($this->f[$fnn]['func'], $args)); // yay... recursion!!!!
+        }
+        // if the token is a number or variable, push it on the stack
+      }
+      else {
+        if (is_numeric($token) || $token[0] == '"') {
+          $stack->push($token);
+        }
+        elseif (array_key_exists($token, $this->v)) {
+          $stack->push($this->v[$token]);
+        }
+        elseif (array_key_exists($token, $vars)) {
+          $stack->push($vars[$token]);
+        }
+        else {
+          return $this->trigger("undefined variable '$token'");
+        }
+      }
     }
+    // when we're out of tokens, the stack should have a single element, the final result
+    if ($stack->count != 1) {
+      return $this->trigger("internal error");
+    }
+
+    return $stack->pop();
+  }
 
-    // trigger an error, but nicely, if need be
-    function trigger($msg) {
-        $this->last_error = $msg;
-        if (!$this->suppress_errors) trigger_error($msg, E_USER_WARNING);
-        return false;
+  // trigger an error, but nicely, if need be
+  function trigger($msg) {
+    $this->errors[] = $msg;
+    $this->last_error = $msg;
+    if (!$this->suppress_errors) {
+      trigger_error($msg, E_USER_WARNING);
     }
+
+    return FALSE;
+  }
 }
 
-// for internal use
+/**
+ * For internal use.
+ */
 class ctools_math_expr_stack {
 
-    var $stack = array();
-    var $count = 0;
+  var $stack = array();
+  var $count = 0;
 
-    function push($val) {
-        $this->stack[$this->count] = $val;
-        $this->count++;
-    }
+  function push($val) {
+    $this->stack[$this->count] = $val;
+    $this->count++;
+  }
 
-    function pop() {
-        if ($this->count > 0) {
-            $this->count--;
-            return $this->stack[$this->count];
-        }
-        return null;
-    }
+  function pop() {
+    if ($this->count > 0) {
+      $this->count--;
 
-    function last($n=1) {
-        return !empty($this->stack[$this->count-$n]) ? $this->stack[$this->count-$n] : NULL;
+      return $this->stack[$this->count];
     }
+
+    return NULL;
+  }
+
+  function last($n = 1) {
+    return !empty($this->stack[$this->count - $n]) ? $this->stack[$this->count - $n] : NULL;
+  }
 }
 
+function ctools_math_expr_if($expr, $if, $else = NULL) {
+  return $expr ? $if : $else;
+}
+
+function ctools_math_expr_number($arg) {
+  // Remove any non-digits so that numbers like $4,511.23 still work.
+  // @todo: locale could break this sincein some locales that's $4.512,33
+  // so there needs to be a way to detect that and make it work properly.
+  $arg = preg_replace("/[^0-9\.]/", '', $arg);
+  return $arg;
+}
diff --git a/tests/math_expression.test b/tests/math_expression.test
index 8810e8c..53ca3a9 100644
--- a/tests/math_expression.test
+++ b/tests/math_expression.test
@@ -39,31 +39,31 @@ public function testArithmetic() {
     $math_expression = new ctools_math_expr();
 
     // Test constant expressions.
-    $this->assertEqual($math_expression->e('2'), 2);
+    $this->assertEqual($math_expression->evaluate('2'), 2);
     $random_number = rand(0, 10);
-    $this->assertEqual($random_number, $math_expression->e((string) $random_number));
+    $this->assertEqual($random_number, $math_expression->evaluate((string) $random_number));
 
     // Test simple arithmetic.
     $random_number_a = rand(5, 10);
     $random_number_b = rand(5, 10);
-    $this->assertEqual($random_number_a + $random_number_b, $math_expression->e("$random_number_a + $random_number_b"));
-    $this->assertEqual($random_number_a - $random_number_b, $math_expression->e("$random_number_a - $random_number_b"));
-    $this->assertEqual($random_number_a * $random_number_b, $math_expression->e("$random_number_a * $random_number_b"));
-    $this->assertEqual($random_number_a / $random_number_b, $math_expression->e("$random_number_a / $random_number_b"));
+    $this->assertEqual($random_number_a + $random_number_b, $math_expression->evaluate("$random_number_a + $random_number_b"));
+    $this->assertEqual($random_number_a - $random_number_b, $math_expression->evaluate("$random_number_a - $random_number_b"));
+    $this->assertEqual($random_number_a * $random_number_b, $math_expression->evaluate("$random_number_a * $random_number_b"));
+    $this->assertEqual(round($random_number_a / $random_number_b, 8), round($math_expression->evaluate("$random_number_a / $random_number_b"), 8));
 
     // Test Associative property.
     $random_number_c = rand(5, 10);
-    $this->assertEqual($math_expression->e("$random_number_a + ($random_number_b + $random_number_c)"), $math_expression->e("($random_number_a + $random_number_b) + $random_number_c"));
-    $this->assertEqual($math_expression->e("$random_number_a * ($random_number_b * $random_number_c)"), $math_expression->e("($random_number_a * $random_number_b) * $random_number_c"));
+    $this->assertEqual($math_expression->evaluate("$random_number_a + ($random_number_b + $random_number_c)"), $math_expression->evaluate("($random_number_a + $random_number_b) + $random_number_c"));
+    $this->assertEqual($math_expression->evaluate("$random_number_a * ($random_number_b * $random_number_c)"), $math_expression->evaluate("($random_number_a * $random_number_b) * $random_number_c"));
 
     // Test Commutative property.
-    $this->assertEqual($math_expression->e("$random_number_a + $random_number_b"), $math_expression->e("$random_number_b + $random_number_a"));
-    $this->assertEqual($math_expression->e("$random_number_a * $random_number_b"), $math_expression->e("$random_number_b * $random_number_a"));
+    $this->assertEqual($math_expression->evaluate("$random_number_a + $random_number_b"), $math_expression->evaluate("$random_number_b + $random_number_a"));
+    $this->assertEqual($math_expression->evaluate("$random_number_a * $random_number_b"), $math_expression->evaluate("$random_number_b * $random_number_a"));
 
     // Test Distributive property.
-    $this->assertEqual($math_expression->e("($random_number_a + $random_number_b) * $random_number_c"), $math_expression->e("($random_number_a * $random_number_c + $random_number_b * $random_number_c)"));
+    $this->assertEqual($math_expression->evaluate("($random_number_a + $random_number_b) * $random_number_c"), $math_expression->evaluate("($random_number_a * $random_number_c + $random_number_b * $random_number_c)"));
 
-    $this->assertEqual(pow($random_number_a, $random_number_b), $math_expression->e("$random_number_a ^ $random_number_b"));
+    $this->assertEqual(pow($random_number_a, $random_number_b), $math_expression->evaluate("$random_number_a ^ $random_number_b"));
   }
 
   public function testBuildInFunctions() {
@@ -72,26 +72,25 @@ public function testBuildInFunctions() {
     // @todo: maybe run this code multiple times to test different values.
     $random_double = $this->rand01();
     $random_int = rand(5, 10);
-    $this->assertFloat(sin($random_double), $math_expression->e("sin($random_double)"));
-    $this->assertFloat(cos($random_double), $math_expression->e("cos($random_double)"));
-    $this->assertFloat(tan($random_double), $math_expression->e("tan($random_double)"));
-    $this->assertFloat(exp($random_double), $math_expression->e("exp($random_double)"));
-    $this->assertFloat(sqrt($random_double), $math_expression->e("sqrt($random_double)"));
-    $this->assertFloat(log($random_double), $math_expression->e("ln($random_double)"));
-    $this->assertFloat(round($random_double), $math_expression->e("round($random_double)"));
-    $this->assertFloat(abs($random_double + $random_int), $math_expression->e('abs(' . ($random_double + $random_int) . ')'));
-    $this->assertEqual(round($random_double + $random_int), $math_expression->e('round(' . ($random_double + $random_int) . ')'));
-    $this->assertEqual(ceil($random_double + $random_int), $math_expression->e('ceil(' . ($random_double + $random_int) . ')'));
-    $this->assertEqual(floor($random_double + $random_int), $math_expression->e('floor(' . ($random_double + $random_int) . ')'));
+    $this->assertFloat(sin($random_double), $math_expression->evaluate("sin($random_double)"));
+    $this->assertFloat(cos($random_double), $math_expression->evaluate("cos($random_double)"));
+    $this->assertFloat(tan($random_double), $math_expression->evaluate("tan($random_double)"));
+    $this->assertFloat(exp($random_double), $math_expression->evaluate("exp($random_double)"));
+    $this->assertFloat(sqrt($random_double), $math_expression->evaluate("sqrt($random_double)"));
+    $this->assertFloat(log($random_double), $math_expression->evaluate("ln($random_double)"));
+    $this->assertFloat(round($random_double), $math_expression->evaluate("round($random_double)"));
+    $this->assertFloat(abs($random_double + $random_int), $math_expression->evaluate('abs(' . ($random_double + $random_int) . ')'));
+    $this->assertEqual(round($random_double + $random_int), $math_expression->evaluate('round(' . ($random_double + $random_int) . ')'));
+    $this->assertEqual(ceil($random_double + $random_int), $math_expression->evaluate('ceil(' . ($random_double + $random_int) . ')'));
+    $this->assertEqual(floor($random_double + $random_int), $math_expression->evaluate('floor(' . ($random_double + $random_int) . ')'));
 
     // @fixme: you can't run time without an argument.
-    $this->assertFloat(time(), $math_expression->e('time(1)'));
+    $this->assertFloat(time(), $math_expression->evaluate('time(1)'));
 
     $random_double_a = $this->rand01();
     $random_double_b = $this->rand01();
-    // @fixme: max/min don't work at the moment.
-//    $this->assertFloat(max($random_double_a, $random_double_b), $math_expression->e("max($random_double_a, $random_double_b)"));
-//    $this->assertFloat(min($random_double_a, $random_double_b), $math_expression->e("min($random_double_a, $random_double_b)"));
+    $this->assertFloat(max($random_double_a, $random_double_b), $math_expression->evaluate("max($random_double_a, $random_double_b)"));
+    $this->assertFloat(min($random_double_a, $random_double_b), $math_expression->evaluate("min($random_double_a, $random_double_b)"));
   }
 
   public function testVariables() {
@@ -101,11 +100,11 @@ public function testVariables() {
     $random_number_b = rand(5, 10);
 
     // Store the first random number and use it on calculations.
-    $math_expression->e("var = $random_number_a");
-    $this->assertEqual($random_number_a + $random_number_b, $math_expression->e("var + $random_number_b"));
-    $this->assertEqual($random_number_a * $random_number_b, $math_expression->e("var * $random_number_b"));
-    $this->assertEqual($random_number_a - $random_number_b, $math_expression->e("var - $random_number_b"));
-    $this->assertEqual($random_number_a / $random_number_b, $math_expression->e("var / $random_number_b"));
+    $math_expression->evaluate("var = $random_number_a");
+    $this->assertEqual($random_number_a + $random_number_b, $math_expression->evaluate("var + $random_number_b"));
+    $this->assertEqual($random_number_a * $random_number_b, $math_expression->evaluate("var * $random_number_b"));
+    $this->assertEqual($random_number_a - $random_number_b, $math_expression->evaluate("var - $random_number_b"));
+    $this->assertEqual(round($random_number_a / $random_number_b, 8), round($math_expression->evaluate("var / $random_number_b"), 8));
   }
 
   public function testCustomFunctions() {
@@ -115,15 +114,31 @@ public function testCustomFunctions() {
     $random_number_b = rand(5, 10);
 
     // Create a one-argument function.
-    $math_expression->e("f(x) = 2 * x");
-    $this->assertEqual($random_number_a * 2, $math_expression->e("f($random_number_a)"));
-    $this->assertEqual($random_number_b * 2, $math_expression->e("f($random_number_b)"));
+    $math_expression->evaluate("f(x) = 2 * x");
+    $this->assertEqual($random_number_a * 2, $math_expression->evaluate("f($random_number_a)"));
+    $this->assertEqual($random_number_b * 2, $math_expression->evaluate("f($random_number_b)"));
 
     // Create a two-argument function.
-    $math_expression->e("g(x, y) = 2 * x + y");
-    $this->assertEqual($random_number_a * 2 + $random_number_b, $math_expression->e("g($random_number_a, $random_number_b)"));
+    $math_expression->evaluate("g(x, y) = 2 * x + y");
+    $this->assertEqual($random_number_a * 2 + $random_number_b, $math_expression->evaluate("g($random_number_a, $random_number_b)"));
 
     // Use a custom function in another function.
-    $this->assertEqual(($random_number_a * 2 + $random_number_b) * 2, $math_expression->e("f(g($random_number_a, $random_number_b))"));
+    $this->assertEqual(($random_number_a * 2 + $random_number_b) * 2, $math_expression->evaluate("f(g($random_number_a, $random_number_b))"));
   }
+
+  public function testIf() {
+    $math_expression = new ctools_math_expr();
+
+    $random_number_a = rand(1, 5);
+    $random_number_b = rand(10, 20);
+
+    $this->assertEqual($math_expression->evaluate("if(1, $random_number_a, $random_number_b)"), $random_number_a);
+    $this->assertEqual($math_expression->evaluate("if(1, $random_number_a)"), $random_number_a);
+
+    $this->assertEqual($math_expression->evaluate("if(0, $random_number_a, $random_number_b)"), $random_number_b);
+
+    // Also add an expression so ensure it's evaluated.
+    $this->assertEqual($math_expression->evaluate("if($random_number_a > $random_number_b, $random_number_a, $random_number_b)"), $random_number_b);
+  }
+
 }
diff --git a/tests/object_cache_unit.test b/tests/object_cache_unit.test
new file mode 100644
index 0000000..97b672f
--- /dev/null
+++ b/tests/object_cache_unit.test
@@ -0,0 +1,141 @@
+<?php
+
+/**
+ * Test ctools_cache_find_plugin and the structure of the default cache plugins.
+ */
+class CtoolsUnitObjectCachePlugins extends DrupalWebTestCase {
+
+  /**
+   * {@inheritDoc}
+   */
+  public static function getInfo() {
+    return array(
+      'name' => 'Object cache storage (unit tests)',
+      'description' => 'Verify that objects are written, readable and lockable.',
+      'group' => 'ctools',
+      'dependencies' => array('ctools'),
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  function setUp(array $modules = array()) {
+    $modules[] = 'ctools';
+    parent::setUp($modules);
+  }
+
+  /**
+   * Check that the supplied array looks like a ctools cache plugin.
+   *
+   * @param mixed $p
+   *   The value to check.
+   * @param string $msg
+   *   Prefix of the assertion message.
+   */
+  public function assertValidCachePlugin($p, $msg) {
+    //$this->pass(var_export($p, TRUE));
+    $this->assertTrue(is_array($p), $msg . ': plugin is an array');
+
+    $this->assertEqual($p['plugin type'], 'cache', $msg . ': type is cache');
+
+    $this->assertTrue(array_key_exists('title', $p), $msg . ': title element exists');
+    $this->assertTrue(!empty($p['title']) && is_string($p['title']), $msg . ': title is a string');
+
+    $this->assertTrue(array_key_exists('cache get', $p), $msg . ': has a get function');
+    $this->assertTrue(!empty($p['cache get']) && is_callable($p['cache get']), $msg . ': get is executable');
+
+    $this->assertTrue(array_key_exists('cache set', $p), $msg . ': has a set function');
+    $this->assertTrue(!empty($p['cache set']) && is_callable($p['cache set']), $msg . ': set is executable');
+
+    // @todo Clear is required by the spec (cache.inc:40..48): but export_ui
+    // cache doesn't implement it. Enable the assertions when that problem is
+    // solved.
+    // $this->assertTrue(array_key_exists('cache clear', $p), $msg . ': has a clear function');
+    // $this->assertTrue(is_callable($p['cache clear']), $msg . ': clear is executable');
+
+    // @todo Break is optional acc'd to spec but does anything implement it?
+    $this->assertTrue(!array_key_exists('cache break', $p) || is_callable($p['cache break']), $msg . ': break is executable');
+
+    // @todo Finalize is optional so don't fail if not there??
+    $this->assertTrue(!array_key_exists('cache finalize', $p) || is_callable($p['cache finalize']), $msg . ': finalize is executable');
+  }
+
+  /**
+   * Check the return value of the ctools_cache_find_plugin function.
+   *
+   * @param mixed $p the value to check.
+   * @param string $msg prefix of the assertion message.
+   */
+  public function assertPluginNotFound($p, $msg) {
+    //$this->pass(var_export($p, TRUE));
+    $this->assertTrue(is_array($p), $msg . ': is an array');
+    $plugin = array_shift($p);
+    $this->assertNull($plugin, $msg . ': no plugin info');
+    $data = array_shift($p);
+    $this->assertTrue(empty($data) || is_string($data), $msg . ': data string-like');
+    $this->assertTrue(empty($p), $msg . ': just two elements');
+  }
+
+  /**
+   * Check the return value of the ctools_cache_find_plugin function.
+   *
+   * @param mixed $p the value to check.
+   * @param string $msg prefix of the assertion message.
+   */
+  public function assertPluginFound($p, $msg) {
+    //$this->pass(var_export($p, TRUE));
+    $this->assertTrue(is_array($p), $msg . ': is an array');
+    $plugin = array_shift($p);
+    $this->assertTrue(is_array($plugin), $msg . ': has plugin data');
+    $data = array_shift($p);
+    $this->assertTrue(empty($data) || is_string($data), $msg . ': data is string-like');
+    $this->assertTrue(empty($p), $msg . ': just two elements');
+  }
+
+  /**
+   * Test to see that we can find the standard simple plugin.
+   */
+  public function testFindSimpleCachePlugin() {
+    ctools_include('cache');
+
+    // The simple plugin.
+    $plugin = ctools_cache_find_plugin('simple');
+    $this->assertPluginFound($plugin, 'The Simple Cache plugin is present');
+    $this->assertValidCachePlugin($plugin[0], 'The Simple Cache plugin');
+
+    // The simple plugin, with ::.
+    $plugin = ctools_cache_find_plugin('simple::data');
+    $this->assertPluginFound($plugin, 'The Simple Cache plugin is present, with data');
+  }
+
+  /**
+   * Test to see that we can find the standard export_ui plugin.
+   */
+  public function testFindExportUICachePlugin() {
+    ctools_include('cache');
+
+    // The export plugin.
+    $plugin = ctools_cache_find_plugin('export_ui');
+    $this->assertPluginFound($plugin, 'The Export UI Cache plugin is present');
+    $this->assertValidCachePlugin($plugin[0], 'The Export Cache plugin');
+
+    // The export plugin, with ::.
+    $plugin = ctools_cache_find_plugin('export_ui::data');
+    $this->assertTrue(is_array($plugin), 'The Export UI Cache plugin is present, with data');
+  }
+
+  /**
+   * Test to see that we don't find plugins that aren't there.
+   */
+  public function testFindFoobarbazCachePlugin() {
+    ctools_include('cache');
+
+    // An imaginary foobarbaz plugin.
+    $plugin = ctools_cache_find_plugin('foobarbaz');
+    $this->assertPluginNotFound($plugin, 'The Foobarbaz Cache plugin is absent');
+    $plugin = ctools_cache_find_plugin('foobarbaz::data');
+    $this->assertPluginNotFound($plugin, 'The Foobarbaz Cache plugin is absent, with data');
+  }
+
+}
diff --git a/tests/page_tokens.test b/tests/page_tokens.test
new file mode 100644
index 0000000..6ab973e
--- /dev/null
+++ b/tests/page_tokens.test
@@ -0,0 +1,134 @@
+<?php
+
+/**
+ * Tests for different parts of the ctools object caching system.
+ *
+ * Needs to be a WebTest because need access to database tables.
+ */
+class CtoolsPageTokens extends DrupalWebTestCase {
+
+  /**
+   * {@inheritDoc}
+   */
+  public static function getInfo() {
+    return array(
+      'name' => 'Page token processing',
+      'description' => 'Verify that page tokens can be set and read.',
+      'group' => 'ctools',
+      'dependencies' => array('ctools'),
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  function setUp(array $modules = array()) {
+    $modules[] = 'ctools';
+    parent::setUp($modules);
+
+    // Start each test anew.
+    ctools_reset_page_tokens();
+  }
+
+  /**
+   * Test that we can set page tokens.
+   */
+  public function testSetPageToken() {
+    ctools_set_page_token('id', 'variable', 'test');
+
+    $tokens = ctools_set_page_token();
+    $this->assertTrue(is_array($tokens) && count($tokens) === 1, 'Page tokens no longer empty.');
+    $this->assertEqual($tokens['id'], array('variable', 'test'), 'Page token has correct value.');
+  }
+
+  /**
+   * Test that we can set page tokens.
+   */
+  public function testSetVariableToken() {
+    $string = ctools_set_variable_token('title');
+    $tokens = ctools_set_page_token();
+
+    $this->assertTrue(is_array($tokens) && count($tokens) === 1, 'Page tokens no longer empty');
+    $this->assertEqual($tokens[$string], array('variable', 'title'), 'Page tokens no longer empty');
+  }
+
+  /**
+   * Test that we can set page tokens.
+   */
+  public function testReplaceVariableToken() {
+    $string = ctools_set_variable_token('title');
+    $this->assertEqual($string, '<!-- ctools-page-title -->', 'Expected form of token was found');
+
+    $elements = array(
+      '#type' => 'container',
+      '#attributes' => array('class' => array('test')),
+      'title' => '<h2>Title</h2>',
+      'content' => array(
+        '#type' => 'markup',
+        '#markup' => t('This is my test markup'),
+        '#prefix' => $string,
+      ),
+      'link' => array(
+        '#type' => 'link',
+        '#title' => t('My link'),
+        '#href' => 'node/1',
+      ),
+    );
+    $markup = '<div class="test"><!-- ctools-page-title -->This is my test markup<a href="node/1">My link</a></div>';
+
+    $new_markup = ctools_page_token_processing($markup, $elements);
+
+    $this->assertTrue(is_string($new_markup) && strlen($new_markup) > 1, 'Should return string');
+
+    $this->assertTrue(strstr($new_markup, '<h2>'), 'Variable Token Markup should contain h2 element');
+    $this->assertFalse(strstr($new_markup, 'ctools-page-title'), 'Variable Token Markup should not contain comment element');
+  }
+
+  /**
+   * Test that we can set page tokens.
+   */
+  public function testReplaceCallbackToken() {
+    $string = ctools_set_callback_token('title', 'test_ctools_page_callback_token');
+    $this->assertEqual($string, '<!-- ctools-page-title -->', 'Expected form of token was found');
+
+    $elements = array(
+      '#type' => 'container',
+      '#attributes' => array('class' => array('test')),
+      'content' => array(
+        '#type' => 'markup',
+        '#markup' => t('This is my test markup'),
+        '#prefix' => $string,
+      ),
+      'link' => array(
+        '#type' => 'link',
+        '#title' => t('My link'),
+        '#href' => 'node/1',
+      ),
+    );
+    $markup = '<div class="test"><!-- ctools-page-title -->This is my test markup<a href="node/1">My link</a></div>';
+
+    $new_markup = ctools_page_token_processing($markup, $elements);
+
+    $this->assertTrue(is_string($new_markup) && strlen($new_markup) > 1, 'Should return a non-empty string');
+
+    $this->assertTrue(strstr($new_markup, '<h2>'), 'Callback Token Markup should contain h2 element');
+    $this->assertFalse(strstr($new_markup, 'ctools-page-title'), 'Callback Token Markup should not contain comment element');
+  }
+
+}
+
+/**
+ *
+ * @param $elements
+ *
+ * @return string
+ */
+function test_ctools_page_callback_token($elements) {
+  // Check that 'elements' array looks good.
+  if (isset($elements['content'])) {
+    return '<h2>Title</h2>';
+  }
+  else {
+    return '<!--bad-->';
+  }
+}
diff --git a/tests/uuid_with_uuid.test b/tests/uuid_with_uuid.test
new file mode 100644
index 0000000..13ff0ac
--- /dev/null
+++ b/tests/uuid_with_uuid.test
@@ -0,0 +1,55 @@
+<?php
+
+/**
+ * Test the UUID handling when the UUID module is present.
+ */
+class CtoolsUUIDWithUUID extends DrupalWebTestCase {
+
+  /**
+   * {@inheritDoc}
+   */
+  public static function getInfo() {
+    return array(
+      'name' => 'UUID handing, with UUID module',
+      'description' => 'Check that the CTools UUID functions behave correctly when the UUID module is installed.',
+      'group' => 'ctools',
+      'dependencies' => array('ctools'),
+      // 'dependencies' => array('ctools', 'uuid'),
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  function setUp(array $modules = array()) {
+    $modules[] = 'ctools';
+    // @todo Add UUID as a test dependency and then add comment out this line.
+    // $modules[] = 'uuid';
+    parent::setUp($modules);
+  }
+
+  /**
+   * Check we can get a UUID.
+   *
+   * NB: This test will use one (and only one) of the mechanisms available
+   * from pear,
+   *
+   * @todo Fix this so testbot doesn't fail.
+   */
+  public function DISABLED_testMakeNewUUID() {
+    // drupal_get_filename will report even if the module is disabled.
+    if (drupal_get_filename('module', 'uuid') && !module_exists('uuid')) {
+      module_enable(array('uuid'));
+    }
+    // if we now have uuid module, use it.
+    if (module_exists('uuid')) {
+      $uuid = ctools_uuid_generate();
+      $this->assertTrue(ctools_uuid_is_valid($uuid), 'UUID generated (uuid): ' . $uuid);
+    }
+    else {
+      // otherwise say we can't...
+      $this->verbose('uuid module not present');
+    }
+  }
+
+}
diff --git a/tests/uuid_without_uuid.test b/tests/uuid_without_uuid.test
new file mode 100644
index 0000000..6d62ebf
--- /dev/null
+++ b/tests/uuid_without_uuid.test
@@ -0,0 +1,101 @@
+<?php
+
+/**
+ * Test the UUID handling without the UUID module being present.
+ */
+class CtoolsUUIDWithoutUUID extends DrupalWebTestCase {
+
+  /**
+   * {@inheritDoc}
+   */
+  public static function getInfo() {
+    return array(
+      'name' => 'UUID handing, without UUID module',
+      'description' => 'Check that the CTools UUID functions behave correctly when the UUID module is not installed.',
+      'group' => 'ctools',
+      'dependencies' => array('ctools'),
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  function setUp(array $modules = array()) {
+    $modules[] = 'ctools';
+    parent::setUp($modules);
+  }
+
+  /**
+   * Check the UUID_PATTERN constant exists.
+   *
+   * @todo Fix this so testbot doesn't fail.
+   */
+  public function DISABLED_testHaveUUIDpattern() {
+    ctools_include('uuid');
+    $this->assertTrue(defined('UUID_PATTERN'), 'The UUID_PATTERN constant exists.');
+    $this->assertTrue(is_string(UUID_PATTERN) && strlen(UUID_PATTERN) > 12, 'The UUID_PATTERN has an appropriate value.');
+  }
+
+  /**
+   * Check we can get a UUID when .
+   *
+   * NB: This test will use one (and only one) of the mechanisms available
+   * from pear,
+   *
+   * @todo Fix this so testbot doesn't fail.
+   */
+  public function DISABLED_testMakeNewUUIDRaw() {
+    // drupal_get_filename will report even if the module is disabled.
+    if (drupal_get_filename('module', 'uuid') && module_exists('uuid')) {
+      module_disable(array('uuid'));
+    }
+
+    ctools_include('uuid');
+    $uuid = _ctools_uuid_generate_php();
+    $this->assertTrue(ctools_uuid_is_valid($uuid), 'UUID generated (ctoolsphp): ' . $uuid);
+  }
+
+  /**
+   * Check we can get a UUID when .
+   *
+   * NB: This test will use one (and only one) of the mechanisms available
+   * from pear,
+   *
+   * @todo Fix this so testbot doesn't fail.
+   */
+  public function DISABLED_testMakeNewUUIDWrapper() {
+    // drupal_get_filename will report even if the module is disabled.
+    if (drupal_get_filename('module', 'uuid') && module_exists('uuid')) {
+      module_disable(array('uuid'));
+    }
+
+    $uuid = ctools_uuid_generate();
+    $this->assertTrue(ctools_uuid_is_valid($uuid), 'UUID generated (ctools): ' . $uuid);
+  }
+
+  /**
+   * Check we can verify that a string looks like a UUID.
+   *
+   * @todo Fix this so testbot doesn't fail.
+   */
+  public function DISABLED_testVerifyUUID() {
+    $checks = array(
+      NULL => FALSE,
+      '' => FALSE,
+      '0' => FALSE,
+      'b5827a5cadd311e69a1f936389a27663' => FALSE,  // version 1, no dashes
+      '15ff2566-add3-11e6-b98f' => FALSE,           // incomplete
+
+      '15ff2566-add3-11e6-b98f-080027dc4f7a' => TRUE, // version 1
+      'b5827a5c-add3-11e6-9a1f-936389a27663' => TRUE, // version 1
+      '02d9e6d5-9467-382e-8f9b-9300a64ac3cd' => TRUE, // version 3 url-based
+      '5e330afb-50c6-45c2-a292-99c3168696d2' => TRUE, // version 4 uuid
+      '8f4ca4fd-154e-5063-b6db-aa91af137037' => TRUE, // version 5
+    );
+
+    foreach ($checks as $uuid => $exp) {
+      $this->assertEqual(ctools_uuid_is_valid($uuid), $exp, 'Is Valid: UUIDs match expectations: ' . $uuid);
+    }
+  }
+
+}