bool block_program_test() {
const char* name1 = "/root/hw1_tests/prog1";
const char* name2 = "/root/hw1_tests/prog2";
const char* name3 = "";
int len = strlen(name1);
ASSERT_TEST(block_program(NULL, 5) == -1);
ASSERT_TEST(errno == EINVAL);
ASSERT_TEST(block_program(name3, 0) == -1);
ASSERT_TEST(errno == EINVAL);
ASSERT_TEST(block_program(name1, 0) == -1);
ASSERT_TEST(errno == EINVAL);
ASSERT_TEST(block_program(name2, len) == 0);
ASSERT_TEST(block_program(name1, len) == 0);
ASSERT_TEST(block_program(name2, len) == 1);
ASSERT_TEST(block_program(name1, len) == 1);
char *argva[] = {"/root/hw1_tests/prog1", 0};
char *argvb[] = {"/root/hw1_tests/prog2", 0};
//fails
execv(name1, argva);
execv(name2, argvb);
unblock_program (name1, len);
unblock_program (name2, len);
return true;
}
void test2() {
assert(get_blocked_count() == 0);
int status;
char *argva[] = {A_NAME, 0};
char *argvb[] = {B_NAME, 0};
if (!fork()) {
assert(get_blocked_count() == 0);
execv(PROG_A, argva);
exit(1); // shouldn't happen
}
wait(&status);
assert(WEXITSTATUS(status) == 0); // assuming a.out exits with 0
assert(block_program(PROG_A, strlen(PROG_A)) == 0);
assert(block_program(PROG_B, strlen(PROG_B)) == 0);
assert(block_program(PROG_A, strlen(PROG_A)) == 1);
assert(block_program(PROG_B, strlen(PROG_B)) == 1);
if (!fork()) {
assert(get_blocked_count() == 2);
execv(PROG_B, argvb);
execv(PROG_A, argva);
execv(PROG_B, argvb);
int cpid = fork();
if (!cpid) {
char log[20][256];
int n = get_forbidden_tries(getppid(), log, 2);
assert(n == 2);
assert(strncmp(log[0], PROG_B, strlen(PROG_B)) == 0);
assert(strncmp(log[1], PROG_A, strlen(PROG_A)) == 0);
exit(1);
}
int status2;
waitpid(cpid, &status2, 0);
assert(WEXITSTATUS(status2) == 1);
exit(1);
}
wait(&status);
assert(WEXITSTATUS(status) == 1);
assert(unblock_program(PROG_A, strlen(PROG_A)) == 0);
assert(unblock_program(PROG_B, strlen(PROG_B)) == 0);
assert(get_blocked_count() == 0);
}
bool get_blocked_count_test() {
ASSERT_TEST(get_blocked_count() == 0);
const char* name1 = "prog1";
const char* name2 = "prog2";
const char* name3 = "prog3";
block_program(name1, 5);
ASSERT_TEST(get_blocked_count() == 1);
block_program(name1, 5);
ASSERT_TEST(get_blocked_count() == 1);
block_program(name2, 5);
ASSERT_TEST(get_blocked_count() == 2);
unblock_program(name1, 5);
ASSERT_TEST(get_blocked_count() == 1);
block_program(NULL, 5);
ASSERT_TEST(get_blocked_count() == 1);
block_program(name3, 0);
ASSERT_TEST(get_blocked_count() == 1);
unblock_program(name2, 5);
ASSERT_TEST(get_blocked_count() == 0);
return true;
}
bool unblock_test() {
const char* name1 = "/root/hw1_tests/prog1";
const char* name2 = "/root/hw1_tests/prog2";
const char* name3 = "/root/hw1_tests/prog3";
const char* name4 = "/root/hw1_tests/prog4";
int name_len = strlen(name1);
block_program(name1, name_len);
block_program(name2, name_len);
block_program(name3, name_len);
block_program(name4, name_len);
ASSERT_TEST(unblock_program(NULL, 3) == -1);
ASSERT_TEST(errno == EINVAL);
ASSERT_TEST(unblock_program("d", 0) == -1);
ASSERT_TEST(errno == EINVAL);
//wasn't blocked
ASSERT_TEST(unblock_program("d", 1) == 1);
char *argva[] = {"/root/hw1_tests/prog1", 0};
char *argvb[] = {"/root/hw1_tests/prog2", 0};
ASSERT_TEST(unblock_program(name1, name_len) == 0);
int status;
if(fork() == 0) { //should succeed
execv(name1, argva);
}
//new addition
wait(&status);
assert(WEXITSTATUS(status) == 0);
//already unblocked, should fail
ASSERT_TEST(unblock_program(name1, name_len) == 1);
//unblocking the rest
ASSERT_TEST(unblock_program(name2, name_len) == 0);
ASSERT_TEST(unblock_program(name3, name_len) == 0);
ASSERT_TEST(unblock_program(name4, name_len) == 0);
return true;
}
bool log_test() {
const char* name1 = "/root/hw1_tests/prog1";
const char* name2 = "/root/hw1_tests/prog2";
const char* name3 = "/root/hw1_tests/prog3";
const char* name4 = "/root/hw1_tests/prog4";
const char* test_str = "test";
int len = strlen(name1);
block_program(name1, len);
block_program(name2, len);
char *argva[] = {"/root/hw1_tests/prog1", 0};
char *argvb[] = {"/root/hw1_tests/prog2", 0};
char *argvc[] = {"/root/hw1_tests/prog3", 0};
char *argvd[] = {"/root/hw1_tests/prog4", 0};
// should all fail
execv(name1, argva);
execv(name2, argvb);
//this fails just because the programs don't exist
execv(name3, argvc);
execv(name4, argvd);
//a few more times (logged fails)
execv(name1, argva);
execv(name2, argvb);
execv(name2, argva);
execv(name1, argvb);
//final result: 1, 2, 1, 2, 2, 1
int log_len = 6;
char log[log_len][256];
init_log(log, log_len);
ASSERT_TEST(get_forbidden_tries(-2, log, 3) == -1);
ASSERT_TEST(errno == ESRCH);
ASSERT_TEST(get_forbidden_tries(getpid(), log, 0) == -1);
ASSERT_TEST(errno == EINVAL);
ASSERT_TEST(get_forbidden_tries(getpid(), log, 1) == 1);
for(int i = 0; i < log_len; i++) {
switch(i) {
case 0 :
ASSERT_TEST(strcmp(log[i], name1) == 0);
break;
default:
ASSERT_TEST(strcmp(log[i], test_str) == 0);
}
}
init_log(log, log_len);
ASSERT_TEST(get_forbidden_tries(getpid(), log, 40) == log_len);
for(int i = 0; i < log_len; i++) {
switch(i) {
case 0 :
ASSERT_TEST(strcmp(log[i], name1) == 0);
break;
case 1 :
ASSERT_TEST(strcmp(log[i], name2) == 0);
break;
case 2 :
ASSERT_TEST(strcmp(log[i], name1) == 0);
break;
case 3 :
ASSERT_TEST(strcmp(log[i], name2) == 0);
break;
case 4 :
ASSERT_TEST(strcmp(log[i], name2) == 0);
break;
case 5 :
ASSERT_TEST(strcmp(log[i], name1) == 0);
break;
default:
ASSERT_TEST(strcmp(log[i], test_str) == 0);
}
}
init_log(log, log_len);
ASSERT_TEST(get_forbidden_tries(getpid(), log, 3) == 3);
for(int i = 0; i < log_len; i++) {
switch(i) {
case 0 :
ASSERT_TEST(strcmp(log[i], name1) == 0);
break;
case 1 :
ASSERT_TEST(strcmp(log[i], name2) == 0);
break;
case 2 :
ASSERT_TEST(strcmp(log[i], name1) == 0);
break;
default:
ASSERT_TEST(strcmp(log[i], test_str) == 0);
}
}
int status;
if(fork() == 0) {
init_log(log, log_len);
ASSERT_TEST(get_forbidden_tries(getpid(), log, log_len) == 0);
for(int i = 0; i < log_len; i++) {
ASSERT_TEST(strcmp(log[i], test_str) == 0);
}
_exit(EXIT_SUCCESS);
}
wait(&status);
assert(WEXITSTATUS(status) == EXIT_SUCCESS);
unblock_program(name1, len);
unblock_program(name2, len);
return true;
}
bool is_program_blocked_test() {
const char* name1 = "/root/hw1_tests/prog1";
const char* name2 = "/root/hw1_tests/prog2";
const char* name3 = "/root/hw1_tests/prog3";
const char* name4 = "/root/hw1_tests/prog4";
int len = strlen(name1);
//checking errors
ASSERT_TEST(is_program_blocked(NULL, len));
ASSERT_TEST(errno == EINVAL);
ASSERT_TEST(is_program_blocked("da", 0));
ASSERT_TEST(errno == EINVAL);
ASSERT_TEST(is_program_blocked(NULL, 0));
ASSERT_TEST(errno == EINVAL);
block_program(name1, len);
block_program(name2, len);
ASSERT_TEST(is_program_blocked(name1, len));
ASSERT_TEST(is_program_blocked(name2, len));
ASSERT_TEST(is_program_blocked(name3, len) == 0);
ASSERT_TEST(is_program_blocked(name4, len) == 0);
ASSERT_TEST(is_program_blocked("adar", 4) == 0);
block_program(name3, len);
block_program(name4, len);
ASSERT_TEST(is_program_blocked(name3, len));
ASSERT_TEST(is_program_blocked(name4, len));
unblock_program(name3, len);
ASSERT_TEST(is_program_blocked(name1, len));
ASSERT_TEST(is_program_blocked(name2, len));
ASSERT_TEST(is_program_blocked(name3, len) == 0);
ASSERT_TEST(is_program_blocked(name4, len));
unblock_program(name4, len);
ASSERT_TEST(is_program_blocked(name1, len));
ASSERT_TEST(is_program_blocked(name2, len));
ASSERT_TEST(is_program_blocked(name3, len) == 0);
ASSERT_TEST(is_program_blocked(name4, len) == 0);
//errors again because why not
ASSERT_TEST(is_program_blocked(NULL, len));
ASSERT_TEST(errno == EINVAL);
ASSERT_TEST(is_program_blocked("da", 0));
ASSERT_TEST(errno == EINVAL);
ASSERT_TEST(is_program_blocked(NULL, 0));
ASSERT_TEST(errno == EINVAL);
unblock_program(name1, len);
ASSERT_TEST(is_program_blocked(name1, len) == 0);
ASSERT_TEST(is_program_blocked(name2, len));
ASSERT_TEST(is_program_blocked(name3, len) == 0);
ASSERT_TEST(is_program_blocked(name4, len) == 0);
unblock_program(name2, len);
ASSERT_TEST(is_program_blocked(name1, len) == 0);
ASSERT_TEST(is_program_blocked(name2, len)== 0);
ASSERT_TEST(is_program_blocked(name3, len) == 0);
ASSERT_TEST(is_program_blocked(name4, len) == 0);
return true;
}
void test1() {
/* Assuming no blocked programs before the test runs. If that's not
* the case, you should unblock any programs before */
assert(get_blocked_count() == 0);
assert(block_program(0, strlen(PROG_A)) == -1);
assert(errno == EINVAL);
assert(is_program_blocked(PROG_A, strlen(PROG_A)) == 0);
assert(block_program(PROG_A, strlen(PROG_A)) == 0);
assert(is_program_blocked(PROG_A, strlen(PROG_A)) == 1);
assert(block_program(PROG_A, strlen(PROG_A)) == 1);
assert(get_blocked_count() == 1);
assert(block_program(PROG_B, strlen(PROG_B)) == 0);
assert(block_program(PROG_B, strlen(PROG_B)) == 1);
assert(get_blocked_count() == 2);
char *argva[] = {A_NAME, 0};
char *argvb[] = {B_NAME, 0};
char log[20][256];
// should all fail
execv(PROG_A, argva);
assert(get_forbidden_tries(getpid(), log, 20)==1);
execv(PROG_B, argvb);
assert(get_forbidden_tries(getpid(), log, 20)==2);
execv(PROG_A, argva);
assert(get_forbidden_tries(getpid(), log, 20)==3);
execv(PROG_A, argva);
assert(get_forbidden_tries(getpid(), log, 20)==4);
execv(PROG_B, argvb);
assert(get_forbidden_tries(getpid(), log, 20)==5);
execv(PROG_B, argvb);
assert(get_forbidden_tries(getpid(), log, 20)==6);
assert(get_forbidden_tries(getpid(), log, 0) == -1);
assert(errno == EINVAL);
assert(get_forbidden_tries(-5, log, 20) == -1);
assert(errno == ESRCH);
assert(get_forbidden_tries(getpid(), (void*)5, 20) == -1);
assert(errno == EFAULT);
int n = get_forbidden_tries(getpid(), log, 20);
assert(n == 6);
assert(strncmp(log[0], PROG_A, strlen(PROG_A)) == 0);
assert(strncmp(log[1], PROG_B, strlen(PROG_B)) == 0);
assert(strncmp(log[2], PROG_A, strlen(PROG_A)) == 0);
assert(strncmp(log[3], PROG_A, strlen(PROG_A)) == 0);
assert(strncmp(log[4], PROG_B, strlen(PROG_B)) == 0);
assert(strncmp(log[5], PROG_B, strlen(PROG_B)) == 0);
assert(unblock_program(0, 11) == -1);
assert(errno == EINVAL);
assert(unblock_program(PROG_A, strlen(PROG_A)) == 0);
assert(unblock_program(PROG_A, strlen(PROG_A)) == 1);
assert(is_program_blocked(PROG_B, strlen(PROG_B)) == 1);
assert(get_blocked_count() == 1);
assert(unblock_program(PROG_B, strlen(PROG_B)) == 0);
assert(is_program_blocked(PROG_A, strlen(PROG_A)) == 0);
assert(is_program_blocked(PROG_B, strlen(PROG_B)) == 0);
assert(unblock_program(PROG_B, strlen(PROG_B)) == 1);
assert(is_program_blocked(PROG_A, strlen(PROG_A)) == 0);
assert(get_blocked_count() == 0);
}
