Initial Contribution
diff --git a/amend/test_permissions.c b/amend/test_permissions.c
new file mode 100644
index 0000000..c389456
--- /dev/null
+++ b/amend/test_permissions.c
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#undef NDEBUG
+#include <assert.h>
+#include "permissions.h"
+
+static int
+test_permission_list()
+{
+ PermissionRequestList list;
+ int ret;
+ int numRequests;
+
+ /* Bad parameter
+ */
+ ret = initPermissionRequestList(NULL);
+ assert(ret < 0);
+
+ /* Good parameter
+ */
+ ret = initPermissionRequestList(&list);
+ assert(ret == 0);
+
+ /* Bad parameters
+ */
+ ret = addPermissionRequestToList(NULL, NULL, false, 0);
+ assert(ret < 0);
+
+ ret = addPermissionRequestToList(&list, NULL, false, 0);
+ assert(ret < 0);
+
+ /* Good parameters
+ */
+ numRequests = 0;
+
+ ret = addPermissionRequestToList(&list, "one", false, 1);
+ assert(ret == 0);
+ numRequests++;
+
+ ret = addPermissionRequestToList(&list, "two", false, 2);
+ assert(ret == 0);
+ numRequests++;
+
+ ret = addPermissionRequestToList(&list, "three", false, 3);
+ assert(ret == 0);
+ numRequests++;
+
+ ret = addPermissionRequestToList(&list, "recursive", true, 55);
+ assert(ret == 0);
+ numRequests++;
+
+ /* Validate the list
+ */
+ assert(list.requests != NULL);
+ assert(list.numRequests == numRequests);
+ assert(list.numRequests <= list.requestsAllocated);
+ bool sawOne = false;
+ bool sawTwo = false;
+ bool sawThree = false;
+ bool sawRecursive = false;
+ int i;
+ for (i = 0; i < list.numRequests; i++) {
+ PermissionRequest *req = &list.requests[i];
+ assert(req->allowed == 0);
+
+ /* Order isn't guaranteed, so we have to switch every time.
+ */
+ if (strcmp(req->path, "one") == 0) {
+ assert(!sawOne);
+ assert(req->requested == 1);
+ assert(!req->recursive);
+ sawOne = true;
+ } else if (strcmp(req->path, "two") == 0) {
+ assert(!sawTwo);
+ assert(req->requested == 2);
+ assert(!req->recursive);
+ sawTwo = true;
+ } else if (strcmp(req->path, "three") == 0) {
+ assert(!sawThree);
+ assert(req->requested == 3);
+ assert(!req->recursive);
+ sawThree = true;
+ } else if (strcmp(req->path, "recursive") == 0) {
+ assert(!sawRecursive);
+ assert(req->requested == 55);
+ assert(req->recursive);
+ sawRecursive = true;
+ } else {
+ assert(false);
+ }
+ }
+ assert(sawOne);
+ assert(sawTwo);
+ assert(sawThree);
+ assert(sawRecursive);
+
+ /* Smoke test the teardown
+ */
+ freePermissionRequestListElements(&list);
+
+ return 0;
+}
+
+static int
+test_permission_table()
+{
+ int ret;
+
+ /* Test the global permissions table.
+ * Try calling functions without initializing first.
+ */
+ ret = registerPermissionSet(0, NULL);
+ assert(ret < 0);
+
+ ret = countPermissionConflicts((PermissionRequestList *)16, false);
+ assert(ret < 0);
+
+ ret = getPermissionCount();
+ assert(ret < 0);
+
+ const Permission *p;
+ p = getPermissionAt(0);
+ assert(p == NULL);
+
+ /* Initialize.
+ */
+ ret = permissionInit();
+ assert(ret == 0);
+
+ /* Make sure we can't initialize twice.
+ */
+ ret = permissionInit();
+ assert(ret < 0);
+
+ /* Test the inspection functions.
+ */
+ ret = getPermissionCount();
+ assert(ret == 0);
+
+ p = getPermissionAt(-1);
+ assert(p == NULL);
+
+ p = getPermissionAt(0);
+ assert(p == NULL);
+
+ p = getPermissionAt(1);
+ assert(p == NULL);
+
+ /* Test registerPermissionSet().
+ * Try some bad parameter values.
+ */
+ ret = registerPermissionSet(-1, NULL);
+ assert(ret < 0);
+
+ ret = registerPermissionSet(1, NULL);
+ assert(ret < 0);
+
+ /* Register some permissions.
+ */
+ Permission p1;
+ p1.path = "one";
+ p1.allowed = 1;
+ ret = registerPermissionSet(1, &p1);
+ assert(ret == 0);
+ ret = getPermissionCount();
+ assert(ret == 1);
+
+ Permission p2[2];
+ p2[0].path = "two";
+ p2[0].allowed = 2;
+ p2[1].path = "three";
+ p2[1].allowed = 3;
+ ret = registerPermissionSet(2, p2);
+ assert(ret == 0);
+ ret = getPermissionCount();
+ assert(ret == 3);
+
+ ret = registerPermissionSet(0, NULL);
+ assert(ret == 0);
+ ret = getPermissionCount();
+ assert(ret == 3);
+
+ p1.path = "four";
+ p1.allowed = 4;
+ ret = registerPermissionSet(1, &p1);
+ assert(ret == 0);
+
+ /* Make sure the table looks correct.
+ * Order is important; more-recent additions
+ * should appear at higher indices.
+ */
+ ret = getPermissionCount();
+ assert(ret == 4);
+
+ int i;
+ for (i = 0; i < ret; i++) {
+ const Permission *p;
+ p = getPermissionAt(i);
+ assert(p != NULL);
+ assert(p->allowed == (unsigned int)(i + 1));
+ switch (i) {
+ case 0:
+ assert(strcmp(p->path, "one") == 0);
+ break;
+ case 1:
+ assert(strcmp(p->path, "two") == 0);
+ break;
+ case 2:
+ assert(strcmp(p->path, "three") == 0);
+ break;
+ case 3:
+ assert(strcmp(p->path, "four") == 0);
+ break;
+ default:
+ assert(!"internal error");
+ break;
+ }
+ }
+ p = getPermissionAt(ret);
+ assert(p == NULL);
+
+ /* Smoke test the teardown
+ */
+ permissionCleanup();
+
+ return 0;
+}
+
+static int
+test_allowed_permissions()
+{
+ int ret;
+ int numPerms;
+
+ /* Make sure these fail before initialization.
+ */
+ ret = countPermissionConflicts((PermissionRequestList *)1, false);
+ assert(ret < 0);
+
+ ret = getAllowedPermissions((const char *)1, false, (unsigned int *)1);
+ assert(ret < 0);
+
+ /* Initialize.
+ */
+ ret = permissionInit();
+ assert(ret == 0);
+
+ /* Make sure countPermissionConflicts() fails with bad parameters.
+ */
+ ret = countPermissionConflicts(NULL, false);
+ assert(ret < 0);
+
+ /* Register a set of permissions.
+ */
+ Permission perms[] = {
+ { "/", PERM_NONE },
+ { "/stat", PERM_STAT },
+ { "/read", PERMSET_READ },
+ { "/write", PERMSET_WRITE },
+ { "/.stat", PERM_STAT },
+ { "/.stat/.read", PERMSET_READ },
+ { "/.stat/.read/.write", PERMSET_WRITE },
+ { "/.stat/.write", PERMSET_WRITE },
+ };
+ numPerms = sizeof(perms) / sizeof(perms[0]);
+ ret = registerPermissionSet(numPerms, perms);
+ assert(ret == 0);
+
+ /* Build a permission request list.
+ */
+ PermissionRequestList list;
+ ret = initPermissionRequestList(&list);
+ assert(ret == 0);
+
+ ret = addPermissionRequestToList(&list, "/stat", false, PERM_STAT);
+ assert(ret == 0);
+
+ ret = addPermissionRequestToList(&list, "/read", false, PERM_READ);
+ assert(ret == 0);
+
+ ret = addPermissionRequestToList(&list, "/write", false, PERM_WRITE);
+ assert(ret == 0);
+
+ //TODO: cover more cases once the permission stuff has been implemented
+
+ /* All of the requests in the list should be allowed.
+ */
+ ret = countPermissionConflicts(&list, false);
+ assert(ret == 0);
+
+ /* Add a request that will be denied.
+ */
+ ret = addPermissionRequestToList(&list, "/stat", false, 1<<31 | PERM_STAT);
+ assert(ret == 0);
+
+ ret = countPermissionConflicts(&list, false);
+ assert(ret == 1);
+
+ //TODO: more tests
+
+ permissionCleanup();
+
+ return 0;
+}
+
+int
+test_permissions()
+{
+ int ret;
+
+ ret = test_permission_list();
+ if (ret != 0) {
+ fprintf(stderr, "test_permission_list() failed: %d\n", ret);
+ return ret;
+ }
+
+ ret = test_permission_table();
+ if (ret != 0) {
+ fprintf(stderr, "test_permission_table() failed: %d\n", ret);
+ return ret;
+ }
+
+ ret = test_allowed_permissions();
+ if (ret != 0) {
+ fprintf(stderr, "test_permission_table() failed: %d\n", ret);
+ return ret;
+ }
+
+ return 0;
+}