simplefiles

url.c (5003B)

---

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "url.h"
 
 struct encode_test_case {
 	const char *name;
 	const char *input;
 	const char *expected;
 };
 
 struct decode_test_case {
 	const char *name;
 	const char *input;
 	const char *expected;
 	int expected_result;
 };
 
 static const struct encode_test_case encode_tests[] = {
 	/* Unreserved characters should not be encoded. */
 	{ "simple filename", "file.txt", "file.txt" },
 	{ "alphanumeric", "file123", "file123" },
 	{ "hyphen", "my-file.txt", "my-file.txt" },
 	{ "underscore", "my_file.txt", "my_file.txt" },
 	{ "dot", "file.txt", "file.txt" },
 	{ "tilde", "~file.txt", "~file.txt" },
 
 	/* Characters requiring encoding. */
 	{ "space", "my file.txt", "my%20file.txt" },
 	{ "ampersand", "&file.txt", "%26file.txt" },
 	{ "plus", "a+b.txt", "a%2Bb.txt" },
 	{ "percent", "100%.txt", "100%25.txt" },
 	{ "question mark", "file?.txt", "file%3F.txt" },
 	{ "equals", "file=name.txt", "file%3Dname.txt" },
 	{ "slash", "foo/bar.txt", "foo%2Fbar.txt" },
 	{ "backslash", "foo\\bar.txt", "foo%5Cbar.txt" },
 	{ "hash", "file#1.txt", "file%231.txt" },
 	{ "quote", "file\".txt", "file%22.txt" },
 
 	/* Empty string. */
 	{ "empty", "", "" },
 };
 
 static const struct decode_test_case decode_tests[] = {
 	/* Plain strings. */
 	{ "simple filename", "file.txt", "file.txt", 0 },
 	{ "alphanumeric", "file123", "file123", 0 },
 	{ "hyphen", "my-file.txt", "my-file.txt", 0 },
 	{ "underscore", "my_file.txt", "my_file.txt", 0 },
 	{ "dot", "file.txt", "file.txt", 0 },
 	{ "tilde", "~file.txt", "~file.txt", 0 },
 
 	/* Encoded characters. */
 	{ "space", "my%20file.txt", "my file.txt", 0 },
 	{ "plus", "my+file.txt", "my file.txt", 0 },
 	{ "ampersand", "%26file.txt", "&file.txt", 0 },
 	{ "percent", "100%25.txt", "100%.txt", 0 },
 	{ "question mark", "file%3F.txt", "file?.txt", 0 },
 	{ "equals", "file%3Dname.txt", "file=name.txt", 0 },
 	{ "slash", "foo%2Fbar.txt", "foo/bar.txt", 0 },
 	{ "backslash", "foo%5Cbar.txt", "foo\\bar.txt", 0 },
 	{ "hash", "file%23.txt", "file#.txt", 0 },
 	{ "quote", "file%22.txt", "file\".txt", 0 },
 
 	/* Hexadecimal case should both work. */
 	{ "lowercase hex", "%2f", "/", 0 },
 	{ "uppercase hex", "%2F", "/", 0 },
 	{ "mixed hex", "%2f%2F", "//", 0 },
 
 	/* Encoded traversal must decode successfully;
 	 * valid_filename() is responsible for rejecting it. */
 	{ "encoded dot", "%2e", ".", 0 },
 	{ "encoded dot dot", "%2e%2e", "..", 0 },
 	{ "encoded traversal", "%2e%2e%2ffile.txt",
 	    "../file.txt", 0 },
 
 	/* Empty string. */
 	{ "empty", "", "", 0 },
 
 	/* Invalid percent encodings. */
 	{ "trailing percent", "%", NULL, -1 },
 	{ "one hex digit", "%2", NULL, -1 },
 	{ "invalid hex", "%ZZ", NULL, -1 },
 	{ "invalid high digit", "%G0", NULL, -1 },
 	{ "invalid low digit", "%0G", NULL, -1 },
 	{ "incomplete encoding", "file%2", NULL, -1 },
 
 	/* Encoded NUL must be rejected. */
 	{ "encoded NUL", "file%00.txt", NULL, -1 },
 };
 
 static int
 test_encode(void)
 {
 	size_t i;
 	int failures = 0;
 
 	for (i = 0;
 	    i < sizeof(encode_tests) / sizeof(encode_tests[0]);
 	    i++) {
 		char *got;
 
 		got = url_encode(encode_tests[i].input);
 
 		if (got == NULL) {
 			fprintf(stderr,
 			    "FAIL: %s: url_encode() returned NULL\n",
 			    encode_tests[i].name);
 			failures++;
 			continue;
 		}
 
 		if (strcmp(got, encode_tests[i].expected) != 0) {
 			fprintf(stderr,
 			    "FAIL: %s: url_encode(%s) returned %s, "
 			    "expected %s\n",
 			    encode_tests[i].name,
 			    encode_tests[i].input,
 			    got,
 			    encode_tests[i].expected);
 			failures++;
 		} else {
 			printf("ok: encode %s\n",
 			    encode_tests[i].name);
 		}
 
 		free(got);
 	}
 
 	return failures;
 }
 
 static int
 test_decode(void)
 {
 	size_t i;
 	int failures = 0;
 
 	for (i = 0;
 	    i < sizeof(decode_tests) / sizeof(decode_tests[0]);
 	    i++) {
 		char *input;
 		int got;
 
 		input = malloc(strlen(decode_tests[i].input) + 1);
 		if (input == NULL) {
 			fprintf(stderr,
 			    "FAIL: %s: malloc failed\n",
 			    decode_tests[i].name);
 			failures++;
 			continue;
 		}
 
 		strcpy(input, decode_tests[i].input);
 
 		got = url_decode(input);
 
 		if (got != decode_tests[i].expected_result) {
 			fprintf(stderr,
 			    "FAIL: %s: url_decode() returned %d, "
 			    "expected %d\n",
 			    decode_tests[i].name,
 			    got,
 			    decode_tests[i].expected_result);
 			failures++;
 			free(input);
 			continue;
 		}
 
 		if (got == 0 &&
 		    strcmp(input, decode_tests[i].expected) != 0) {
 			fprintf(stderr,
 			    "FAIL: %s: url_decode(%s) returned %s, "
 			    "expected %s\n",
 			    decode_tests[i].name,
 			    decode_tests[i].input,
 			    input,
 			    decode_tests[i].expected);
 			failures++;
 		} else {
 			printf("ok: decode %s\n",
 			    decode_tests[i].name);
 		}
 
 		free(input);
 	}
 
 	return failures;
 }
 
 int
 main(void)
 {
 	int failures;
 
 	failures = 0;
 
 	failures += test_encode();
 	failures += test_decode();
 
 	if (failures != 0) {
 		fprintf(stderr,
 		    "%d test(s) failed\n",
 		    failures);
 		return EXIT_FAILURE;
 	}
 
 	printf("all tests passed\n");
 	return EXIT_SUCCESS;
 }