path_simplify now returns int, has better tests

3 files changed, 44 insertions, 27 deletions

diff --git a/src/kernel/tests/vfs.c b/src/kernel/tests/vfs.c
index a5a6848..017f36d 100644
--- a/src/kernel/tests/vfs.c
+++ b/src/kernel/tests/vfs.c
@@ -3,31 +3,48 @@
 #include <kernel/vfs/path.h>
 
 TEST(path_simplify) {
-	char buf[256];
+#define TEST_WRAPPER(argument, result) do { \
+		int len = path_simplify(argument, buf, sizeof(argument) - 1); \
+		if (result == 0) { \
+			TEST_COND(len < 0); \
+		} else { \
+			TEST_COND(len > 0); \
+			/* TODO check equality */ \
+		} \
+	} while (0)
 
-	// some easy valid cases
-	TEST_COND( path_simplify("/asdf", buf, 5));
-	TEST_COND( path_simplify("/asd/", buf, 5));
-	TEST_COND( path_simplify("/a/./", buf, 5));
-	TEST_COND( path_simplify("/a/..", buf, 5));
-	TEST_COND( path_simplify("/a//.", buf, 5));
+	char buf[256];
 
-	// .. going under the root or close to it
-	TEST_COND(!path_simplify("/../123456", buf, 10));
-	TEST_COND(!path_simplify("/./a/../..", buf, 10));
-	TEST_COND( path_simplify("/a/a/../..", buf, 10));
-	TEST_COND(!path_simplify("/////../..", buf, 10));
-	TEST_COND(!path_simplify("//a//../..", buf, 10));
+	// some easy cases first
+	TEST_WRAPPER("/",         "/");
+	TEST_WRAPPER("/asdf",     "/asdf");
+	TEST_WRAPPER("/asdf/",    "/asdf/");
+	TEST_WRAPPER("/asdf//",   "/asdf/");
+	TEST_WRAPPER("/asdf/./",  "/asdf/");
+	TEST_WRAPPER("/a/./b",    "/a/b");
+	TEST_WRAPPER("/a/./b/",   "/a/b/");
 
-	// relative paths aren't allowed
-	TEST_COND(!path_simplify("apath", buf, 5));
-	TEST_COND(!path_simplify("a/pth", buf, 5));
-	TEST_COND(!path_simplify("../th", buf, 5));
+	// some slightly less easy cases
+	TEST_WRAPPER("/asdf/..",  "/");
+	TEST_WRAPPER("/asdf/../", "/");
+	TEST_WRAPPER("/asdf/.",   "/asdf/");
+	TEST_WRAPPER("/asdf//.",  "/asdf/");
 
-	// this includes empty paths
-	TEST_COND(!path_simplify("", buf, 1));
+	// going under the root or close to it
+	TEST_WRAPPER("/../asdf",   0);
+	TEST_WRAPPER("/../asdf/",  0);
+	TEST_WRAPPER("/./a/../..", 0);
+	TEST_WRAPPER("/a/a/../..", "/");
+	TEST_WRAPPER("/////../..", 0);
+	TEST_WRAPPER("//a//../..", 0);
 
-	// TODO test if the paths are simplified correctly
+	// relative paths aren't allowed
+	TEST_WRAPPER("relative",   0);
+	TEST_WRAPPER("some/stuff", 0);
+	TEST_WRAPPER("./stuff",    0);
+	TEST_WRAPPER("../stuff",   0);
+	TEST_WRAPPER("",           0);
+#undef TEST_WRAPPER
 }
 
 void tests_vfs() {
diff --git a/src/kernel/vfs/path.c b/src/kernel/vfs/path.c
index 8662f03..bd17e29 100644
--- a/src/kernel/vfs/path.c
+++ b/src/kernel/vfs/path.c
@@ -1,9 +1,9 @@
 #include <kernel/vfs/path.h>
 #include <kernel/panic.h>
 
-bool path_simplify(const char *in, char *out, size_t len) {
-	if (len == 0)     return false; // empty paths are invalid
-	if (in[0] != '/') return false; // so are relative paths
+int path_simplify(const char *in, char *out, size_t len) {
+	if (len == 0)     return -1; // empty paths are invalid
+	if (in[0] != '/') return -1; // so are relative paths
 
 	int depth = 0;
 	int seg_len; // the length of the current path segment
@@ -33,12 +33,12 @@ bool path_simplify(const char *in, char *out, size_t len) {
 		} else if (seg_len == 2 && in[i + 1] == '.' && in[i + 2] == '.') {
 			// the segment is /../
 			if (--depth < 0)
-				return false;
+				return -1;
 		} else {
 			// normal segment
 			depth++;
 		}
 	}
 
-	return true;
+	return 1; // TODO
 }
diff --git a/src/kernel/vfs/path.h b/src/kernel/vfs/path.h
index 22dc754..3aefccf 100644
--- a/src/kernel/vfs/path.h
+++ b/src/kernel/vfs/path.h
@@ -6,6 +6,6 @@
  * *in and *out can't overlap unless they're equal. Then, the path is modified
  * in-place.
  *
- * @return Was the path valid? If this is false, *out is undefined
+ * @return length of the string in *out, always less than len. Negative if the path was invalid.
  */
-bool path_simplify(const char *in, char *out, size_t len);
+int path_simplify(const char *in, char *out, size_t len);