Implemented test as a builtin (!)

FishsFish.xcodeproj/project.pbxproj

@@ -111,6 +111,7 @@
 		D0B6B0FF14E88BA400AD6C10 /* color.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = color.h; sourceTree = "<group>"; };
 		D0C6FCC914CFA4B0004CE8AD /* autoload.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = autoload.cpp; sourceTree = "<group>"; };
 		D0C6FCCB14CFA4B7004CE8AD /* autoload.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = autoload.h; sourceTree = "<group>"; };
+		D0F3373A1506DE3C00ECEFC0 /* builtin_test.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = builtin_test.cpp; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXGroup section */
@@ -125,6 +126,7 @@
 				D0A0853213B3ACEE0099B651 /* builtin_jobs.cpp */,
 				D0A0853313B3ACEE0099B651 /* builtin_set.cpp */,
 				D0A0853413B3ACEE0099B651 /* builtin_ulimit.cpp */,
+				D0F3373A1506DE3C00ECEFC0 /* builtin_test.cpp */,
 				D0A0853513B3ACEE0099B651 /* builtin.cpp */,
 				D0B6B0FF14E88BA400AD6C10 /* color.h */,
 				D0B6B0FE14E88BA400AD6C10 /* color.cpp */,

Makefile.in

@@ -96,7 +96,8 @@ FISH_OBJS := function.o builtin.o complete.o env.o exec.o expand.o		\
 	tokenizer.o wildcard.o wgetopt.o wutil.o input.o output.o intern.o	\
 	env_universal.o env_universal_common.o input_common.o event.o		\
 	signal.o io.o parse_util.o common.o screen.o path.o autoload.o		\
-	parser_keywords.o iothread.o builtin_scripts.o color.o postfork.o
+	parser_keywords.o iothread.o builtin_scripts.o color.o postfork.o	\
+	builtin_test.o
 
 FISH_INDENT_OBJS := fish_indent.o print_help.o common.o	\
 parser_keywords.o wutil.o tokenizer.o

builtin.cpp

@@ -384,6 +384,9 @@ static void builtin_missing_argument( parser_t &parser, const wchar_t *cmd, cons
 #include "builtin_ulimit.cpp"
 #include "builtin_jobs.cpp"
 
+/* builtin_test lives in builtin_test.cpp */
+int builtin_test( parser_t &parser, wchar_t **argv );
+
 /**
    List all current key bindings
  */
@@ -3574,6 +3577,7 @@ static const builtin_data_t builtin_datas[]=
 	{ 		L"set",  &builtin_set, N_( L"Handle environment variables" )   },
 	{ 		L"status",  &builtin_status, N_( L"Return status information about fish" )  },
 	{ 		L"switch",  &builtin_switch, N_( L"Conditionally execute a block of commands" )   },
+    { 		L"test",  &builtin_test, N_( L"Test a condition" )   },
 	{ 		L"ulimit",  &builtin_ulimit, N_( L"Set or get the shells resource usage limits" )  },
 	{ 		L"while",  &builtin_generic, N_( L"Perform a command multiple times" )   }
 };

builtin_test.cpp

@@ -0,0 +1,618 @@
+/** \file builtin_test.cpp Functions defining the test builtin
+
+Functions used for implementing the test builtin. 
+Implemented from scratch (yes, really) by way of IEEE 1003.1 as reference.
+
+*/
+
+#include "config.h"
+#include "common.h"
+#include "builtin.h"
+#include "wutil.h"
+#include "proc.h"
+#include <sys/stat.h>
+#include <memory>
+
+
+enum {
+    BUILTIN_TEST_SUCCESS = STATUS_BUILTIN_OK,
+    BUILTIN_TEST_FAIL = STATUS_BUILTIN_ERROR
+};
+
+
+int builtin_test( parser_t &parser, wchar_t **argv );
+
+static const wchar_t * const condstr[] = {
+    L"!", L"&&", L"||", L"==", L"!=", L"<", L">", L"-nt", L"-ot", L"-ef", L"-eq",
+    L"-ne", L"-lt", L"-gt", L"-le", L"-ge", L"=~"
+};
+
+namespace test_expressions {
+    
+    enum token_t {
+        test_unknown,               // arbitrary string
+        
+        test_bang,                  // "!", inverts sense
+        
+        test_filetype_b,            // "-b", for block special files
+        test_filetype_c,            // "-c" for character special files
+        test_filetype_d,            // "-d" for directories
+        test_filetype_e,            // "-e" for files that exist
+        test_filetype_f,            // "-f" for for regular files
+        test_filetype_g,            // "-g" for set-group-id
+        test_filetype_h,            // "-h" for symbolic links
+        test_filetype_L,            // "-L", same as -h
+        test_filetype_p,            // "-p", for FIFO
+        test_filetype_S,            // "-S", socket
+        
+        test_filesize_s,            // "-s", size greater than zero
+        
+        test_filedesc_t,            // "-t", whether the fd is associated with a terminal
+        
+        test_fileperm_r,            // "-r", read permission
+        test_fileperm_u,            // "-u", whether file is setuid
+        test_fileperm_w,            // "-w", whether file write permission is allowed
+        test_fileperm_x,            // "-x", whether file execute/search is allowed
+        
+        test_string_n,              // "-n", non-empty string
+        test_string_z,              // "-z", true if length of string is 0
+        test_string_equal,          // "=", true if strings are identical
+        test_string_not_equal,      // "!=", true if strings are not identical
+        
+        test_number_equal,          // "-eq", true if numbers are equal
+        test_number_not_equal,      // "-ne", true if numbers are not equal
+        test_number_greater,        // "-gt", true if first number is larger than second
+        test_number_greater_equal,  // "-ge", true if first number is at least second
+        test_number_lesser,         // "-lt", true if first number is smaller than second
+        test_number_lesser_equal,   // "-le", true if first number is at most second
+        
+        test_combine_and,            // "-a", true if left and right are both true
+        test_combine_or             // "-o", true if either left or right is true
+    };
+    
+    static bool binary_primary_evaluate(test_expressions::token_t token, const wcstring &left, const wcstring &right, wcstring_list_t &errors);
+    static bool unary_primary_evaluate(test_expressions::token_t token, const wcstring &arg, wcstring_list_t &errors);
+
+    
+    enum {
+        UNARY_PRIMARY = 1 << 0,
+        BINARY_PRIMARY = 1 << 1
+    };
+    
+    static const struct token_info_t { token_t tok; const wchar_t *string; unsigned int flags; } token_infos[] =
+    {
+        {test_unknown, L"", 0},
+        {test_bang, L"!", 0},
+        {test_filetype_b, L"-b", UNARY_PRIMARY},
+        {test_filetype_c, L"-c", UNARY_PRIMARY},
+        {test_filetype_d, L"-d", UNARY_PRIMARY},
+        {test_filetype_e, L"-e", UNARY_PRIMARY},
+        {test_filetype_f, L"-f", UNARY_PRIMARY},
+        {test_filetype_g, L"-g", UNARY_PRIMARY},
+        {test_filetype_h, L"-h", UNARY_PRIMARY},
+        {test_filetype_L, L"-L", UNARY_PRIMARY},
+        {test_filetype_p, L"-p", UNARY_PRIMARY},
+        {test_filetype_S, L"-S", UNARY_PRIMARY},
+        {test_filesize_s, L"-s", UNARY_PRIMARY},
+        {test_filedesc_t, L"-t", UNARY_PRIMARY},
+        {test_fileperm_r, L"-r", UNARY_PRIMARY},
+        {test_fileperm_u, L"-u", UNARY_PRIMARY},
+        {test_fileperm_w, L"-w", UNARY_PRIMARY},
+        {test_fileperm_x, L"-x", UNARY_PRIMARY},
+        {test_string_n, L"-n", UNARY_PRIMARY},
+        {test_string_z, L"-z", UNARY_PRIMARY},
+        {test_string_equal, L"=", BINARY_PRIMARY},
+        {test_string_not_equal, L"!=", BINARY_PRIMARY},
+        {test_number_equal, L"-eq", BINARY_PRIMARY},
+        {test_number_not_equal, L"-ne", BINARY_PRIMARY},
+        {test_number_greater, L"-gt", BINARY_PRIMARY},
+        {test_number_greater_equal, L"-ge", BINARY_PRIMARY},
+        {test_number_lesser, L"-lt", BINARY_PRIMARY},
+        {test_number_lesser_equal, L"-le", BINARY_PRIMARY},
+        {test_combine_and, L"-a", 0},
+        {test_combine_or, L"-o", 0}
+    };
+    
+    const token_info_t *token_for_string(const wcstring &str) {
+        for (size_t i=0; i < sizeof token_infos / sizeof *token_infos; i++) {
+            if (str == token_infos[i].string) {
+                return &token_infos[i];
+            }
+        }
+        return &token_infos[0];
+    }
+
+    
+    /* Grammar.
+    
+        <expr> = <combining_expr>
+                 
+        <combining_expr> = <unary_expr> and/or <combining_expr> |
+                           <combining_expr>
+        
+        <unary_expr> = bang <unary_expr> |
+                      <primary>
+                     
+        <primary> = <unary_primary> arg |
+                    arg <binary_primary> arg
+                
+    */
+    
+    class expression;
+    class test_parser {
+        private:
+        wcstring_list_t strings;
+        wcstring_list_t errors;
+        
+        expression *error(const wchar_t *fmt, ...);
+        void add_error(const wchar_t *fmt, ...);
+        
+        const wcstring &arg(unsigned int idx) { return strings.at(idx); }
+        
+        public:
+        test_parser(const wcstring_list_t &val) : strings(val)
+        { }
+        
+        expression *parse_expression(unsigned int start, unsigned int end);
+        expression *parse_combining_expression(unsigned int start, unsigned int end);
+        expression *parse_unary_expression(unsigned int start, unsigned int end);
+        
+        expression *parse_primary(unsigned int start, unsigned int end);
+        expression *parse_unary_primary(unsigned int start, unsigned int end);
+        expression *parse_binary_primary(unsigned int start, unsigned int end);
+        
+        static expression *parse_args(const wcstring_list_t &args, wcstring &err);
+    };
+    
+    struct range_t {
+        unsigned int start;
+        unsigned int end;
+        
+        range_t(unsigned s, unsigned e) : start(s), end(e) { }
+    };
+
+
+    /* Base class for expressions */
+    class expression {
+        protected:
+        expression(token_t what, range_t where) : token(what), range(where) { }
+        
+        public:
+        const token_t token;
+        range_t range;
+        
+        virtual ~expression() { }
+        
+        // evaluate returns true if the expression is true (i.e. BUILTIN_TEST_SUCCESS)
+        virtual bool evaluate(wcstring_list_t &errors) = 0;
+    };
+
+    typedef std::auto_ptr<expression> expr_ref_t;
+
+    /* Single argument like -n foo */
+    class unary_primary : public expression {
+        public:
+        wcstring arg;
+        unary_primary(token_t tok, range_t where, const wcstring &what) : expression(tok, where), arg(what) { }
+        bool evaluate(wcstring_list_t &errors);
+    };
+
+    /* Two argument primary like foo != bar */
+    class binary_primary : public expression {
+        public:
+        wcstring arg_left;
+        wcstring arg_right;
+        
+        binary_primary(token_t tok, range_t where, const wcstring &left, const wcstring &right) : expression(tok, where), arg_left(left), arg_right(right)
+        { }
+        bool evaluate(wcstring_list_t &errors);
+    };
+    
+    /* Unary operator like bang */
+    class unary_operator : public expression {
+        public:
+        expr_ref_t subject;        
+        unary_operator(token_t tok, range_t where, expr_ref_t &exp) : expression(tok, where), subject(exp) { }
+        bool evaluate(wcstring_list_t &errors);
+    };
+    
+    /* Combining expression. Contains a list of AND or OR expressions. It takes more than two so that we don't have to worry about precedence in the parser. */
+    class combining_expression : public expression {
+        public:
+        const std::vector<expression *> subjects;
+        const std::vector<token_t> combiners;
+        
+        combining_expression(token_t tok, range_t where, const std::vector<expression *> &exprs, const std::vector<token_t> &combs) : expression(tok, where), subjects(exprs), combiners(combs)
+        {
+            /* We should have one more subject than combiner */
+            assert(subjects.size() == combiners.size() + 1);
+        }
+        
+        /* We are responsible for destroying our expressions */
+        virtual ~combining_expression() {
+            for (size_t i=0; i < subjects.size(); i++) {
+                delete subjects[i];
+            }
+        }
+        
+        bool evaluate(wcstring_list_t &errors);
+    };
+    
+    void test_parser::add_error(const wchar_t *fmt, ...) {
+        assert(fmt != NULL);
+        va_list va;
+        va_start(va, fmt);
+        this->errors.push_back(vformat_string(fmt, va));
+        va_end(va);    
+    }
+    
+    expression *test_parser::error(const wchar_t *fmt, ...) {
+        assert(fmt != NULL);
+        va_list va;
+        va_start(va, fmt);
+        this->errors.push_back(vformat_string(fmt, va));
+        va_end(va);
+        return NULL;
+    }
+    
+    expression *test_parser::parse_unary_expression(unsigned int start, unsigned int end) {
+        if (start >= end) {
+            return error(L"Missing argument at index %u", start);
+        }
+        token_t tok = token_for_string(arg(start))->tok;
+        if (tok == test_bang) {
+            expr_ref_t subject(parse_unary_expression(start + 1, end));
+            if (subject.get()) {
+                return new unary_operator(tok, range_t(start, subject->range.end), subject);
+            } else {
+                return NULL;
+            }
+        } else {
+            return parse_primary(start, end);
+        }
+    }
+    
+    /* Parse a combining expression (AND, OR) */
+    expression *test_parser::parse_combining_expression(unsigned int start, unsigned int end) {
+        if (start >= end)
+            return NULL;
+        
+        std::vector<expression *> subjects;
+        std::vector<token_t> combiners;
+        unsigned int idx = start;
+        
+        while (idx < end) {
+            
+            if (! subjects.empty()) {
+                /* This is not the first expression, so we need a combiner. */
+                token_t combiner = token_for_string(arg(idx))->tok;
+                if (combiner != test_combine_and && combiner != test_combine_or) {
+                    add_error(L"Expected combining argument at index %u", idx);
+                    break;
+                }
+                combiners.push_back(combiner);
+                idx++;
+            }
+            
+            /* Parse another expression */
+            expression *expr = parse_unary_expression(idx, end);
+            if (! expr) {
+                add_error(L"Missing argument at index %u", idx);
+                break;
+            }
+            
+            /* Go to the end of this expression */
+            idx = expr->range.end;
+            subjects.push_back(expr);
+        }
+        
+        if (idx >= end) {
+            /* We succeeded. Our new expression takes ownership of all expressions we created. The token we pass is irrelevant. */
+            return new combining_expression(test_combine_and, range_t(start, idx), subjects, combiners);
+        } else {
+            /* Failure; we must delete our expressions since we own them */
+            while (! subjects.empty()) {
+                delete subjects.back();
+                subjects.pop_back();
+            }
+            return NULL;
+        }
+    }
+    
+    expression *test_parser::parse_unary_primary(unsigned int start, unsigned int end) {
+        /* We need two arguments */
+        if (start >= end) {
+            return error(L"Missing argument at index %u", start);
+        }
+        if (start + 1 >= end) {
+            return error(L"Missing argument at index %u", start + 1);
+        }
+        
+        /* All our unary primaries are prefix, so the operator is at start. */
+        const token_info_t *info = token_for_string(arg(start));
+        if (! (info->flags & UNARY_PRIMARY))
+            return NULL;
+        
+        return new unary_primary(info->tok, range_t(start, start + 2), arg(start + 1));
+    }
+    
+    expression *test_parser::parse_binary_primary(unsigned int start, unsigned int end) {
+        /* We need three arguments */
+        for (unsigned int idx = start; idx < start + 3; idx++) {
+            if (idx >= end) {
+                return error(L"Missing argument at index %u", idx);
+            }
+        }
+        
+        /* All our binary primaries are infix, so the operator is at start + 1. */
+        const token_info_t *info = token_for_string(arg(start + 1));
+        if (! (info->flags & BINARY_PRIMARY))
+            return NULL;
+        
+        return new binary_primary(info->tok, range_t(start, start + 3), arg(start), arg(start + 2));
+    }
+
+    expression *test_parser::parse_primary(unsigned int start, unsigned int end) {
+        if (start >= end) {
+            return error(L"Missing argument at index %u", start);
+        }
+        
+        expression *expr = parse_unary_primary(start, end);
+        if (! expr) expr = parse_binary_primary(start, end);
+        return expr;
+    }
+
+    expression *test_parser::parse_expression(unsigned int start, unsigned int end) {
+        if (start >= end) {
+            return error(L"Missing argument at index %u", start);
+        }
+        
+        return parse_combining_expression(start, end);
+    }
+    
+    
+    expression *test_parser::parse_args(const wcstring_list_t &args, wcstring &err) {
+        /* Empty list and one-arg list should be handled by caller */
+        assert(args.size() > 1);
+        
+        test_parser parser(args);
+        expression *result = parser.parse_expression(0, (unsigned int)args.size());
+        /* Handle errors */
+        for (size_t i = 0; i < parser.errors.size(); i++) {
+            if (i > 0)
+                err.push_back(L'\n');
+            err.append(parser.errors.at(i));
+        }
+        return result;
+    }
+    
+    bool unary_primary::evaluate(wcstring_list_t &errors) {
+        return unary_primary_evaluate(token, arg, errors);
+    }
+    
+    bool binary_primary::evaluate(wcstring_list_t &errors) {
+        return binary_primary_evaluate(token, arg_left, arg_right, errors);
+    }
+    
+    bool unary_operator::evaluate(wcstring_list_t &errors) {
+        switch (token) {
+            case test_bang:
+                assert(subject.get());
+                return ! subject->evaluate(errors);
+            default:
+                errors.push_back(format_string(L"Unknown token type in %s", __func__));
+                return false;
+
+        }
+    }
+    
+    bool combining_expression::evaluate(wcstring_list_t &errors) {
+        switch (token) {
+            case test_combine_and:
+            case test_combine_or:
+            {
+                /* One-element case */
+                if (subjects.size() == 1)
+                    return subjects.at(0)->evaluate(errors);
+                
+                /* Evaluate our lists, remembering that AND has higher precedence than OR. We can visualize this as a sequence of OR expressions of AND expressions. */
+                assert(combiners.size() + 1 == subjects.size());
+                assert(! subjects.empty());
+                
+                size_t idx = 0, max = combiners.size();
+                bool or_result = false;
+                while (idx < max) {
+                    if (or_result) {
+                        /* Short circuit */
+                        break;
+                    }
+                    
+                    /* Evaluate a stream of AND starting at given subject index. It may only have one element.  */
+                    bool and_result = true;
+                    for (; idx < max; idx++) {
+                        /* Evaluate it, short-circuiting */
+                        and_result = and_result && subjects.at(idx)->evaluate(errors);
+                        
+                        /* If the combiner at this index (which corresponding to how we combine with the next subject) is not AND, then exit the loop */
+                        if (idx + 1 < max && combiners.at(idx) != test_combine_and) {
+                            idx++;
+                            break;
+                        }
+                    }
+                    
+                    /* OR it in */
+                    or_result = or_result || and_result;
+                }
+                return or_result;
+            }
+            
+            default:
+                errors.push_back(format_string(L"Unknown token type in %s", __func__));
+                return BUILTIN_TEST_FAIL;
+
+        }
+    }
+
+    /* IEEE 1003.1 says nothing about what it means for two strings to be "algebraically equal". For example, should we interpret 0x10 as 0, 10, or 16? Here we use only base 10 and use wcstoll, which allows for leading + and -, and leading whitespace. This matches bash. */
+    static bool parse_number(const wcstring &arg, long long *out) {
+        const wchar_t *str = arg.c_str();
+        wchar_t *endptr = NULL;
+        *out = wcstoll(str, &endptr, 10);
+        return endptr && *endptr == L'\0';
+    }
+
+    static bool binary_primary_evaluate(test_expressions::token_t token, const wcstring &left, const wcstring &right, wcstring_list_t &errors) {
+        using namespace test_expressions;
+        long long left_num, right_num;
+        switch (token) {
+            case test_string_equal:
+                return left == right;
+            
+            case test_string_not_equal:
+                return left != right;
+            
+            case test_number_equal:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num == right_num;
+                
+            case test_number_not_equal:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num != right_num;
+            
+            case test_number_greater:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num > right_num;
+                
+            case test_number_greater_equal:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num >= right_num;
+                
+            case test_number_lesser:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num < right_num;
+                
+            case test_number_lesser_equal:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num <= right_num;
+                
+            default:
+                errors.push_back(format_string(L"Unknown token type in %s", __func__));
+                return false;
+        }
+    }
+
+
+    static bool unary_primary_evaluate(test_expressions::token_t token, const wcstring &arg, wcstring_list_t &errors) {
+        using namespace test_expressions;
+        struct stat buf;
+        long long num;
+        switch (token) {
+            case test_filetype_b:            // "-b", for block special files
+                return !wstat(arg, &buf) && S_ISBLK(buf.st_mode);
+                
+            case test_filetype_c:            // "-c" for character special files
+                return !wstat(arg, &buf) && S_ISCHR(buf.st_mode);
+                
+            case test_filetype_d:            // "-d" for directories
+                return !wstat(arg, &buf) && S_ISDIR(buf.st_mode);
+                
+            case test_filetype_e:            // "-e" for files that exist
+                return !wstat(arg, &buf);
+                
+            case test_filetype_f:            // "-f" for for regular files
+                return !wstat(arg, &buf) && S_ISREG(buf.st_mode);
+            
+            case test_filetype_g:            // "-g" for set-group-id
+                return !wstat(arg, &buf) && (S_ISGID & buf.st_mode);
+                
+            case test_filetype_h:            // "-h" for symbolic links
+            case test_filetype_L:            // "-L", same as -h
+                return !lwstat(arg, &buf) && S_ISLNK(buf.st_mode);
+
+            case test_filetype_p:            // "-p", for FIFO
+                return !wstat(arg, &buf) && S_ISFIFO(buf.st_mode);
+                
+            case test_filetype_S:            // "-S", socket
+                return !wstat(arg, &buf) && S_ISSOCK(buf.st_mode);
+            
+            case test_filesize_s:            // "-s", size greater than zero
+                return !wstat(arg, &buf) && buf.st_size > 0;
+                
+            case test_filedesc_t:            // "-t", whether the fd is associated with a terminal
+                return parse_number(arg, &num) && num == (int)num && isatty((int)num);
+            
+            case test_fileperm_r:            // "-r", read permission
+                return !waccess(arg, R_OK);
+                
+            case test_fileperm_u:            // "-u", whether file is setuid
+                return !wstat(arg, &buf) && (S_ISUID & buf.st_mode);
+                
+            case test_fileperm_w:            // "-w", whether file write permission is allowed
+                return !waccess(arg, W_OK);
+                
+            case test_fileperm_x:            // "-x", whether file execute/search is allowed
+                return !waccess(arg, X_OK);
+            
+            case test_string_n:              // "-n", non-empty string
+                return ! arg.empty();
+                
+            case test_string_z:              // "-z", true if length of string is 0
+                return arg.empty();
+            
+            default:
+                errors.push_back(format_string(L"Unknown token type in %s", __func__));
+                return false;
+        }        
+    }
+
+};
+
+/*
+ * Evaluate a conditional expression given the arguments.
+ * If fromtest is set, the caller is the test or [ builtin;
+ * with the pointer giving the name of the command.
+ * for POSIX conformance this supports a more limited range
+ * of functionality.
+ *
+ * Return status is the final shell status, i.e. 0 for true,
+ * 1 for false and 2 for error.
+ */
+int builtin_test( parser_t &parser, wchar_t **argv )
+{
+    using namespace test_expressions;
+    
+    /* The first argument should be the name of the command ('test') */
+    if (! argv[0])
+        return BUILTIN_TEST_FAIL;
+    
+    size_t argc = 0;
+    while (argv[argc + 1])
+        argc++;
+    const wcstring_list_t args(argv + 1, argv + 1 + argc);
+
+    if (argc == 0) {
+        // Per 1003.1, exit false
+        return BUILTIN_TEST_FAIL;
+    } else if (argc == 1) {
+        // Per 1003.1, exit true if the arg is non-empty
+        return args.at(0).empty() ? BUILTIN_TEST_FAIL : BUILTIN_TEST_SUCCESS;
+    } else {
+        // Try parsing. If expr is not nil, we are responsible for deleting it.
+        wcstring err;
+        expression *expr = test_parser::parse_args(args, err);
+        if (! expr) {
+            printf("Oops! test was given args:\n");
+            for (size_t i=0; i < argc; i++) {
+                printf("\t%ls\n", args.at(i).c_str());
+            }
+            printf("and returned parse error: %ls\n", err.c_str());
+            return BUILTIN_TEST_FAIL;
+        } else {
+            wcstring_list_t eval_errors;
+            bool result = expr->evaluate(eval_errors);
+            if (! eval_errors.empty()) {
+                printf("test returned eval errors:\n");
+                for (size_t i=0; i < eval_errors.size(); i++) {
+                    printf("\t%ls\n", eval_errors.at(i).c_str());
+                }
+            }
+            delete expr;
+            return result ? BUILTIN_TEST_SUCCESS : BUILTIN_TEST_FAIL;
+        }
+    }
+    return 1;
+}

env.cpp

@@ -94,7 +94,7 @@ struct var_entry_t
 
 typedef std::map<wcstring, var_entry_t*> var_table_t;
 
-bool g_log_forks = true;
+bool g_log_forks = false;
 
 
 /**

fish_tests.cpp

@@ -19,7 +19,11 @@
 #include <fcntl.h>
 #include <stdarg.h>
 #include <assert.h>
+#include <iostream>
+#include <string>
+#include <sstream>
 #include <algorithm>
+#include <iterator>
 
 #ifdef HAVE_GETOPT_H
 #include <getopt.h>
@@ -357,7 +361,7 @@ static void test_fork(void) {
             iothread_perform<void>(test_fork_helper, NULL, NULL);
         }
         for (size_t q = 0; q < FORK_LOOP_COUNT; q++) {
-            size_t pids[FORK_COUNT];
+            pid_t pids[FORK_COUNT];
             for (size_t i=0; i < FORK_COUNT; i++) {
                 pid_t pid = execute_fork(false);
                 if (pid > 0) {
@@ -476,7 +480,7 @@ static void test_lru(void) {
     size_t total_nodes = 20;
     for (size_t i=0; i < total_nodes; i++) {
         assert(cache.size() == std::min(i, (size_t)16));
-        lru_node_test_t *node = new lru_node_test_t(format_val(i));
+        lru_node_test_t *node = new lru_node_test_t(to_string(i));
         if (i < 4) expected_evicted.push_back(node);
         // Adding the node the first time should work, and subsequent times should fail
         assert(cache.add_node(node));
@@ -561,9 +565,7 @@ static void test_expand()
 	
 }
 
-/**
-   Test path functions
- */
+/** Test path functions */
 static void test_path()
 {
 	say( L"Testing path functions" );
@@ -577,6 +579,79 @@ static void test_path()
 	}	
 }
 
+/** Test the 'test' builtin */
+int builtin_test( parser_t &parser, wchar_t **argv );
+static bool run_test_test(int expected, wcstring_list_t &lst) {
+    parser_t parser(PARSER_TYPE_GENERAL);
+    size_t i, count = lst.size();
+    wchar_t **argv = new wchar_t *[count+2];
+    argv[0] = (wchar_t *)L"test";
+    for (i=0; i < count; i++) {
+        argv[i+1] = (wchar_t *)lst.at(i).c_str();
+    }
+    argv[i+1] = NULL;
+    int result = builtin_test(parser, argv);
+    delete[] argv;
+    return expected == result;
+}
+
+static bool run_test_test(int expected, const wcstring &str) {
+    using namespace std;
+    wcstring_list_t lst;
+
+    wistringstream iss(str);
+    copy(istream_iterator<wcstring, wchar_t, std::char_traits<wchar_t> >(iss),
+             istream_iterator<wstring, wchar_t, std::char_traits<wchar_t> >(),
+             back_inserter<vector<wcstring> >(lst));
+    return run_test_test(expected, lst);
+}
+
+static void test_test() {
+    say(L"Testing test builtin");
+    
+    assert(run_test_test(0, L"5 -ne 6"));
+    assert(run_test_test(0, L"5 -eq 5"));
+    assert(run_test_test(0, L"0 -eq 0"));
+    assert(run_test_test(0, L"-1 -eq -1"));
+    assert(run_test_test(0, L"1 -ne -1"));
+    assert(run_test_test(1, L"-1 -ne -1"));
+    assert(run_test_test(0, L"abc != def"));
+    assert(run_test_test(1, L"abc = def"));
+    assert(run_test_test(0, L"5 -le 10"));
+    assert(run_test_test(0, L"10 -le 10"));
+    assert(run_test_test(1, L"20 -le 10"));
+    assert(run_test_test(0, L"-1 -le 0"));
+    assert(run_test_test(1, L"0 -le -1"));
+    assert(run_test_test(0, L"15 -ge 10"));
+    assert(run_test_test(0, L"15 -ge 10"));
+    assert(run_test_test(1, L"! 15 -ge 10"));
+    assert(run_test_test(0, L"! ! 15 -ge 10"));
+
+    assert(run_test_test(0, L"0 -ne 1 -a 0 -eq 0"));
+    assert(run_test_test(0, L"0 -ne 1 -a -n 5"));
+    assert(run_test_test(0, L"-n 5 -a 10 -gt 5"));
+    assert(run_test_test(0, L"-n 3 -a -n 5"));
+    
+    /* test precedence:
+            '0 == 0 || 0 == 1 && 0 == 2'
+        should be evaluated as:
+            '0 == 0 || (0 == 1 && 0 == 2)'
+        and therefore true. If it were
+            '(0 == 0 || 0 == 1) && 0 == 2'
+        it would be false. */
+    assert(run_test_test(0, L"0 = 0 -o 0 = 1 -a 0 = 2"));
+    assert(run_test_test(0, L"-n 5 -o 0 = 1 -a 0 = 2"));
+    
+    /* A few lame tests for permissions; these need to be a lot more complete. */
+    assert(run_test_test(0, L"-e /bin/ls"));
+    assert(run_test_test(1, L"-e /bin/ls_not_a_path"));
+    assert(run_test_test(0, L"-x /bin/ls"));
+    assert(run_test_test(1, L"-x /bin/ls_not_a_path"));
+    assert(run_test_test(0, L"-d /bin/"));
+    assert(run_test_test(1, L"-d /bin/ls"));
+        
+}
+
 /** Testing colors */
 static void test_colors()
 {
@@ -721,7 +796,7 @@ void history_tests_t::test_history(void) {
     for (i=1; i <= max; i++) {
         
         /* Generate a value */
-        wcstring value = wcstring(L"test item ") + format_val(i);
+        wcstring value = wcstring(L"test item ") + to_string(i);
         
         /* Maybe add some backslashes */
         if (i % 3 == 0)
@@ -770,6 +845,7 @@ int main( int argc, char **argv )
 	say( L"Testing low-level functionality");
 	say( L"Lines beginning with '(ignore):' are not errors, they are warning messages\ngenerated by the fish parser library when given broken input, and can be\nignored. All actual errors begin with 'Error:'." );
 	set_main_thread();
+    setup_fork_guards();
 	proc_init();	
 	event_init();	
 	function_init();
@@ -785,6 +861,7 @@ int main( int argc, char **argv )
 	test_parser();
 	test_lru();
 	test_expand();
+    test_test();
 	test_path();
     test_colors();
     test_autosuggest();

io.h

@@ -1,6 +1,7 @@
 #ifndef FISH_IO_H
 #define FISH_IO_H
 
+#include <vector>
 #include <tr1/memory>
 using std::tr1::shared_ptr;
 

iothread.cpp

@@ -208,5 +208,5 @@ void iothread_drain_all(void) {
         iothread_service_completion();
     }
     double after = timef();
-    printf("(Waited %.02f msec for %d thread(s) to drain)\n", 1000 * (after - now), thread_count);
+    //printf("(Waited %.02f msec for %d thread(s) to drain)\n", 1000 * (after - now), thread_count);
 }