@@ -131,6 +131,18 @@ TEST score_dot() {

 	PASS();

 }

+TEST score_long_string() {

+	char string[4096];

+	memset(string, 'a', sizeof(string) - 1);

+	string[sizeof(string) - 1] = '\0';

+

+	ASSERT_SCORE_EQ(SCORE_MIN, match("aa", string));

+	ASSERT_SCORE_EQ(SCORE_MIN, match(string, "aa"));

+	ASSERT_SCORE_EQ(SCORE_MIN, match(string, string));

+

+	PASS();

+}

+

 TEST positions_consecutive() {

 	size_t positions[3];

 	match_positions("amo", "app/models/foo", positions);

@@ -210,6 +222,7 @@ SUITE(match_suite) {

 	RUN_TEST(score_slash);

 	RUN_TEST(score_capital);

 	RUN_TEST(score_dot);

+	RUN_TEST(score_long_string);

 	RUN_TEST(positions_consecutive);

 	RUN_TEST(positions_start_of_word);

@@ -7,7 +7,7 @@

 #define SCORE_TOLERANCE 0.000001

 #define ASSERT_SCORE_EQ(a,b) ASSERT_IN_RANGE((a), (b), SCORE_TOLERANCE)

-#define ASSERT_INT_EQ(a,b) ASSERT_EQ_FMT((a), (b), "%d")

+#define ASSERT_SIZE_T_EQ(a,b) ASSERT_EQ_FMT((size_t)(a), (b), "%zu")

 /* has_match(char *needle, char *haystack) */

 TEST exact_match_should_return_true() {

@@ -134,9 +134,9 @@ TEST score_dot() {

 TEST positions_consecutive() {

 	size_t positions[3];

 	match_positions("amo", "app/models/foo", positions);

-	ASSERT_INT_EQ(0, positions[0]);

-	ASSERT_INT_EQ(4, positions[1]);

-	ASSERT_INT_EQ(5, positions[2]);

+	ASSERT_SIZE_T_EQ(0, positions[0]);

+	ASSERT_SIZE_T_EQ(4, positions[1]);

+	ASSERT_SIZE_T_EQ(5, positions[2]);

 	PASS();

 }

@@ -148,10 +148,10 @@ TEST positions_start_of_word() {

 	 */

 	size_t positions[4];

 	match_positions("amor", "app/models/order", positions);

-	ASSERT_INT_EQ(0, positions[0]);

-	ASSERT_INT_EQ(4, positions[1]);

-	ASSERT_INT_EQ(11, positions[2]);

-	ASSERT_INT_EQ(12, positions[3]);

+	ASSERT_SIZE_T_EQ(0, positions[0]);

+	ASSERT_SIZE_T_EQ(4, positions[1]);

+	ASSERT_SIZE_T_EQ(11, positions[2]);

+	ASSERT_SIZE_T_EQ(12, positions[3]);

 	PASS();

 }

@@ -159,12 +159,12 @@ TEST positions_start_of_word() {

 TEST positions_no_bonuses() {

 	size_t positions[2];

 	match_positions("as", "tags", positions);

-	ASSERT_INT_EQ(1, positions[0]);

-	ASSERT_INT_EQ(3, positions[1]);

+	ASSERT_SIZE_T_EQ(1, positions[0]);

+	ASSERT_SIZE_T_EQ(3, positions[1]);

 	match_positions("as", "examples.txt", positions);

-	ASSERT_INT_EQ(2, positions[0]);

-	ASSERT_INT_EQ(7, positions[1]);

+	ASSERT_SIZE_T_EQ(2, positions[0]);

+	ASSERT_SIZE_T_EQ(7, positions[1]);

 	PASS();

 }

@@ -172,9 +172,9 @@ TEST positions_no_bonuses() {

 TEST positions_multiple_candidates_start_of_words() {

 	size_t positions[3];

 	match_positions("abc", "a/a/b/c/c", positions);

-	ASSERT_INT_EQ(2, positions[0]);

-	ASSERT_INT_EQ(4, positions[1]);

-	ASSERT_INT_EQ(6, positions[2]);

+	ASSERT_SIZE_T_EQ(2, positions[0]);

+	ASSERT_SIZE_T_EQ(4, positions[1]);

+	ASSERT_SIZE_T_EQ(6, positions[2]);

 	PASS();

 }

@@ -182,9 +182,9 @@ TEST positions_multiple_candidates_start_of_words() {

 TEST positions_exact_match() {

 	size_t positions[3];

 	match_positions("foo", "foo", positions);

-	ASSERT_INT_EQ(0, positions[0]);

-	ASSERT_INT_EQ(1, positions[1]);

-	ASSERT_INT_EQ(2, positions[2]);

+	ASSERT_SIZE_T_EQ(0, positions[0]);

+	ASSERT_SIZE_T_EQ(1, positions[1]);

+	ASSERT_SIZE_T_EQ(2, positions[2]);

 	PASS();

 }

@@ -5,7 +5,8 @@

 #include "greatest/greatest.h"

-#define ASSERT_SCORE_EQ(a,b) ASSERT_EQ_FMT((a), (b), "%f")

+#define SCORE_TOLERANCE 0.000001

+#define ASSERT_SCORE_EQ(a,b) ASSERT_IN_RANGE((a), (b), SCORE_TOLERANCE)

 #define ASSERT_INT_EQ(a,b) ASSERT_EQ_FMT((a), (b), "%d")

 /* has_match(char *needle, char *haystack) */

@@ -5,6 +5,9 @@

 #include "greatest/greatest.h"

+#define ASSERT_SCORE_EQ(a,b) ASSERT_EQ_FMT((a), (b), "%f")

+#define ASSERT_INT_EQ(a,b) ASSERT_EQ_FMT((a), (b), "%d")

+

 /* has_match(char *needle, char *haystack) */

 TEST exact_match_should_return_true() {

 	ASSERT(has_match("a", "a"));

@@ -76,63 +79,63 @@ TEST should_prefer_start_of_candidate() {

 TEST score_exact_match() {

 	/* Exact match is SCORE_MAX */

-	ASSERT_EQ(SCORE_MAX, match("abc", "abc"));

-	ASSERT_EQ(SCORE_MAX, match("aBc", "abC"));

+	ASSERT_SCORE_EQ(SCORE_MAX, match("abc", "abc"));

+	ASSERT_SCORE_EQ(SCORE_MAX, match("aBc", "abC"));

 	PASS();

 }

 TEST score_empty_query() {

 	/* Empty query always results in SCORE_MIN */

-	ASSERT_EQ(SCORE_MIN, match("", ""));

-	ASSERT_EQ(SCORE_MIN, match("", "a"));

-	ASSERT_EQ(SCORE_MIN, match("", "bb"));

+	ASSERT_SCORE_EQ(SCORE_MIN, match("", ""));

+	ASSERT_SCORE_EQ(SCORE_MIN, match("", "a"));

+	ASSERT_SCORE_EQ(SCORE_MIN, match("", "bb"));

 	PASS();

 }

 TEST score_gaps() {

-	ASSERT_EQ(SCORE_GAP_LEADING, match("a", "*a"));

-	ASSERT_EQ(SCORE_GAP_LEADING*2, match("a", "*ba"));

-	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_GAP_TRAILING, match("a", "**a*"));

-	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_GAP_TRAILING*2, match("a", "**a**"));

-	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CONSECUTIVE + SCORE_GAP_TRAILING*2, match("aa", "**aa**"));

-	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_GAP_TRAILING + SCORE_GAP_TRAILING, match("aa", "**a*a**"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING, match("a", "*a"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING*2, match("a", "*ba"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING*2 + SCORE_GAP_TRAILING, match("a", "**a*"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING*2 + SCORE_GAP_TRAILING*2, match("a", "**a**"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CONSECUTIVE + SCORE_GAP_TRAILING*2, match("aa", "**aa**"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING + SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_GAP_TRAILING + SCORE_GAP_TRAILING, match("aa", "**a*a**"));

 	PASS();

 }

 TEST score_consecutive() {

-	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE, match("aa", "*aa"));

-	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE*2, match("aaa", "*aaa"));

-	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_CONSECUTIVE, match("aaa", "*a*aa"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE, match("aa", "*aa"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE*2, match("aaa", "*aaa"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_CONSECUTIVE, match("aaa", "*a*aa"));

 	PASS();

 }

 TEST score_slash() {

-	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_SLASH, match("a", "/a"));

-	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_SLASH, match("a", "*/a"));

-	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_SLASH + SCORE_MATCH_CONSECUTIVE, match("aa", "a/aa"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING + SCORE_MATCH_SLASH, match("a", "/a"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_SLASH, match("a", "*/a"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_SLASH + SCORE_MATCH_CONSECUTIVE, match("aa", "a/aa"));

 	PASS();

 }

 TEST score_capital() {

-	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CAPITAL, match("a", "bA"));

-	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CAPITAL, match("a", "baA"));

-	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CAPITAL + SCORE_MATCH_CONSECUTIVE, match("aa", "baAa"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CAPITAL, match("a", "bA"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CAPITAL, match("a", "baA"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CAPITAL + SCORE_MATCH_CONSECUTIVE, match("aa", "baAa"));

 	PASS();

 }

 TEST score_dot() {

-	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_DOT, match("a", ".a"));

-	ASSERT_EQ(SCORE_GAP_LEADING*3 + SCORE_MATCH_DOT, match("a", "*a.a"));

-	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_DOT, match("a", "*a.a"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING + SCORE_MATCH_DOT, match("a", ".a"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING*3 + SCORE_MATCH_DOT, match("a", "*a.a"));

+	ASSERT_SCORE_EQ(SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_DOT, match("a", "*a.a"));

 	PASS();

 }

 TEST positions_consecutive() {

 	size_t positions[3];

 	match_positions("amo", "app/models/foo", positions);

-	ASSERT_EQ(0, positions[0]);

-	ASSERT_EQ(4, positions[1]);

-	ASSERT_EQ(5, positions[2]);

+	ASSERT_INT_EQ(0, positions[0]);

+	ASSERT_INT_EQ(4, positions[1]);

+	ASSERT_INT_EQ(5, positions[2]);

 	PASS();

 }

@@ -144,10 +147,10 @@ TEST positions_start_of_word() {

 	 */

 	size_t positions[4];

 	match_positions("amor", "app/models/order", positions);

-	ASSERT_EQ(0, positions[0]);

-	ASSERT_EQ(4, positions[1]);

-	ASSERT_EQ(11, positions[2]);

-	ASSERT_EQ(12, positions[3]);

+	ASSERT_INT_EQ(0, positions[0]);

+	ASSERT_INT_EQ(4, positions[1]);

+	ASSERT_INT_EQ(11, positions[2]);

+	ASSERT_INT_EQ(12, positions[3]);

 	PASS();

 }

@@ -155,12 +158,12 @@ TEST positions_start_of_word() {

 TEST positions_no_bonuses() {

 	size_t positions[2];

 	match_positions("as", "tags", positions);

-	ASSERT_EQ(1, positions[0]);

-	ASSERT_EQ(3, positions[1]);

+	ASSERT_INT_EQ(1, positions[0]);

+	ASSERT_INT_EQ(3, positions[1]);

 	match_positions("as", "examples.txt", positions);

-	ASSERT_EQ(2, positions[0]);

-	ASSERT_EQ(7, positions[1]);

+	ASSERT_INT_EQ(2, positions[0]);

+	ASSERT_INT_EQ(7, positions[1]);

 	PASS();

 }

@@ -168,9 +171,9 @@ TEST positions_no_bonuses() {

 TEST positions_multiple_candidates_start_of_words() {

 	size_t positions[3];

 	match_positions("abc", "a/a/b/c/c", positions);

-	ASSERT_EQ(2, positions[0]);

-	ASSERT_EQ(4, positions[1]);

-	ASSERT_EQ(6, positions[2]);

+	ASSERT_INT_EQ(2, positions[0]);

+	ASSERT_INT_EQ(4, positions[1]);

+	ASSERT_INT_EQ(6, positions[2]);

 	PASS();

 }

@@ -178,9 +181,9 @@ TEST positions_multiple_candidates_start_of_words() {

 TEST positions_exact_match() {

 	size_t positions[3];

 	match_positions("foo", "foo", positions);

-	ASSERT_EQ(0, positions[0]);

-	ASSERT_EQ(1, positions[1]);

-	ASSERT_EQ(2, positions[2]);

+	ASSERT_INT_EQ(0, positions[0]);

+	ASSERT_INT_EQ(1, positions[1]);

+	ASSERT_INT_EQ(2, positions[2]);

 	PASS();

 }

@@ -5,95 +5,129 @@

 #include "greatest/greatest.h"

-TEST test_match() {

+/* has_match(char *needle, char *haystack) */

+TEST exact_match_should_return_true() {

 	ASSERT(has_match("a", "a"));

+	PASS();

+}

+

+TEST partial_match_should_return_true() {

 	ASSERT(has_match("a", "ab"));

 	ASSERT(has_match("a", "ba"));

+	PASS();

+}

+

+TEST match_with_delimiters_in_between() {

 	ASSERT(has_match("abc", "a|b|c"));

+	PASS();

+}

-	/* non-match */

+TEST non_match_should_return_false() {

 	ASSERT(!has_match("a", ""));

 	ASSERT(!has_match("a", "b"));

 	ASSERT(!has_match("ass", "tags"));

+	PASS();

+}

+TEST empty_query_should_always_match() {

 	/* match when query is empty */

 	ASSERT(has_match("", ""));

 	ASSERT(has_match("", "a"));

-

 	PASS();

 }

-TEST test_relative_scores() {

+/* match(char *needle, char *haystack) */

+

+TEST should_prefer_starts_of_words() {

 	/* App/Models/Order is better than App/MOdels/zRder  */

 	ASSERT(match("amor", "app/models/order") > match("amor", "app/models/zrder"));

+	PASS();

+}

+TEST should_prefer_consecutive_letters() {

 	/* App/MOdels/foo is better than App/M/fOo  */

 	ASSERT(match("amo", "app/m/foo") < match("amo", "app/models/foo"));

+	PASS();

+}

+TEST should_prefer_contiguous_over_letter_following_period() {

 	/* GEMFIle.Lock < GEMFILe  */

 	ASSERT(match("gemfil", "Gemfile.lock") < match("gemfil", "Gemfile"));

+	PASS();

+}

-	/* GEMFIle.Lock < GEMFILe  */

-	ASSERT(match("gemfil", "Gemfile.lock") < match("gemfil", "Gemfile"));

-

-	/* Prefer shorter matches */

+TEST should_prefer_shorter_matches() {

 	ASSERT(match("abce", "abcdef") > match("abce", "abc de"));

+	ASSERT(match("abc", "    a b c ") > match("abc", " a  b  c "));

+	ASSERT(match("abc", " a b c    ") > match("abc", " a  b  c "));

+	PASS();

+}

-	/* Prefer shorter candidates */

+TEST should_prefer_shorter_candidates() {

 	ASSERT(match("test", "tests") > match("test", "testing"));

+	PASS();

+}

+TEST should_prefer_start_of_candidate() {

 	/* Scores first letter highly */

 	ASSERT(match("test", "testing") > match("test", "/testing"));

-

-	/* Prefer shorter matches */

-	ASSERT(match("abc", "    a b c ") > match("abc", " a  b  c "));

-	ASSERT(match("abc", " a b c    ") > match("abc", " a  b  c "));

-

 	PASS();

 }

-TEST test_exact_scores() {

+TEST score_exact_match() {

 	/* Exact match is SCORE_MAX */

 	ASSERT_EQ(SCORE_MAX, match("abc", "abc"));

 	ASSERT_EQ(SCORE_MAX, match("aBc", "abC"));

+	PASS();

+}

+TEST score_empty_query() {

 	/* Empty query always results in SCORE_MIN */

 	ASSERT_EQ(SCORE_MIN, match("", ""));

 	ASSERT_EQ(SCORE_MIN, match("", "a"));

 	ASSERT_EQ(SCORE_MIN, match("", "bb"));

+	PASS();

+}

-	/* Gaps */

+TEST score_gaps() {

 	ASSERT_EQ(SCORE_GAP_LEADING, match("a", "*a"));

 	ASSERT_EQ(SCORE_GAP_LEADING*2, match("a", "*ba"));

 	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_GAP_TRAILING, match("a", "**a*"));

 	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_GAP_TRAILING*2, match("a", "**a**"));

 	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CONSECUTIVE + SCORE_GAP_TRAILING*2, match("aa", "**aa**"));

 	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_GAP_TRAILING + SCORE_GAP_TRAILING, match("aa", "**a*a**"));

+	PASS();

+}

-	/* Consecutive */

+TEST score_consecutive() {

 	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE, match("aa", "*aa"));

 	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE*2, match("aaa", "*aaa"));

 	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_CONSECUTIVE, match("aaa", "*a*aa"));

+	PASS();

+}

-	/* Slash */

+TEST score_slash() {

 	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_SLASH, match("a", "/a"));

 	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_SLASH, match("a", "*/a"));

 	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_SLASH + SCORE_MATCH_CONSECUTIVE, match("aa", "a/aa"));

+	PASS();

+}

-	/* Capital */

+TEST score_capital() {

 	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CAPITAL, match("a", "bA"));

 	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CAPITAL, match("a", "baA"));

 	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CAPITAL + SCORE_MATCH_CONSECUTIVE, match("aa", "baAa"));

+	PASS();

+}

-	/* Dot */

+TEST score_dot() {

 	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_DOT, match("a", ".a"));

 	ASSERT_EQ(SCORE_GAP_LEADING*3 + SCORE_MATCH_DOT, match("a", "*a.a"));

 	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_DOT, match("a", "*a.a"));

-

 	PASS();

 }

-TEST test_positions_1() {

+TEST positions_consecutive() {

 	size_t positions[3];

 	match_positions("amo", "app/models/foo", positions);

 	ASSERT_EQ(0, positions[0]);

@@ -103,7 +137,7 @@ TEST test_positions_1() {

 	PASS();

 }

-TEST test_positions_2() {

+TEST positions_start_of_word() {

 	/*

 	 * We should prefer matching the 'o' in order, since it's the beginning

 	 * of a word.

@@ -113,21 +147,17 @@ TEST test_positions_2() {

 	ASSERT_EQ(0, positions[0]);

 	ASSERT_EQ(4, positions[1]);

 	ASSERT_EQ(11, positions[2]);

+	ASSERT_EQ(12, positions[3]);

 	PASS();

 }

-TEST test_positions_3() {

+TEST positions_no_bonuses() {

 	size_t positions[2];

 	match_positions("as", "tags", positions);

 	ASSERT_EQ(1, positions[0]);

 	ASSERT_EQ(3, positions[1]);

-	PASS();

-}

-

-TEST test_positions_4() {

-	size_t positions[2];

 	match_positions("as", "examples.txt", positions);

 	ASSERT_EQ(2, positions[0]);

 	ASSERT_EQ(7, positions[1]);

@@ -135,7 +165,7 @@ TEST test_positions_4() {

 	PASS();

 }

-TEST test_positions_5() {

+TEST positions_multiple_candidates_start_of_words() {

 	size_t positions[3];

 	match_positions("abc", "a/a/b/c/c", positions);

 	ASSERT_EQ(2, positions[0]);

@@ -145,7 +175,7 @@ TEST test_positions_5() {

 	PASS();

 }

-TEST test_positions_exact() {

+TEST positions_exact_match() {

 	size_t positions[3];

 	match_positions("foo", "foo", positions);

 	ASSERT_EQ(0, positions[0]);

@@ -156,13 +186,30 @@ TEST test_positions_exact() {

 }

 SUITE(match_suite) {

-	RUN_TEST(test_match);

-	RUN_TEST(test_relative_scores);

-	RUN_TEST(test_exact_scores);

-	RUN_TEST(test_positions_1);

-	RUN_TEST(test_positions_2);

-	RUN_TEST(test_positions_3);

-	RUN_TEST(test_positions_4);

-	RUN_TEST(test_positions_5);

-	RUN_TEST(test_positions_exact);

+	RUN_TEST(exact_match_should_return_true);

+	RUN_TEST(partial_match_should_return_true);

+	RUN_TEST(empty_query_should_always_match);

+	RUN_TEST(non_match_should_return_false);

+	RUN_TEST(match_with_delimiters_in_between);

+

+	RUN_TEST(should_prefer_starts_of_words);

+	RUN_TEST(should_prefer_consecutive_letters);

+	RUN_TEST(should_prefer_contiguous_over_letter_following_period);

+	RUN_TEST(should_prefer_shorter_matches);

+	RUN_TEST(should_prefer_shorter_candidates);

+	RUN_TEST(should_prefer_start_of_candidate);

+

+	RUN_TEST(score_exact_match);

+	RUN_TEST(score_empty_query);

+	RUN_TEST(score_gaps);

+	RUN_TEST(score_consecutive);

+	RUN_TEST(score_slash);

+	RUN_TEST(score_capital);

+	RUN_TEST(score_dot);

+

+	RUN_TEST(positions_consecutive);

+	RUN_TEST(positions_start_of_word);

+	RUN_TEST(positions_no_bonuses);

+	RUN_TEST(positions_multiple_candidates_start_of_words);

+	RUN_TEST(positions_exact_match);

 }

new file mode 100644

@@ -0,0 +1,168 @@

+#include <stdlib.h>

+

+#include "../config.h"

+#include "match.h"

+

+#include "greatest/greatest.h"

+

+TEST test_match() {

+	ASSERT(has_match("a", "a"));

+	ASSERT(has_match("a", "ab"));

+	ASSERT(has_match("a", "ba"));

+	ASSERT(has_match("abc", "a|b|c"));

+

+	/* non-match */

+	ASSERT(!has_match("a", ""));

+	ASSERT(!has_match("a", "b"));

+	ASSERT(!has_match("ass", "tags"));

+

+	/* match when query is empty */

+	ASSERT(has_match("", ""));

+	ASSERT(has_match("", "a"));

+

+	PASS();

+}

+

+TEST test_relative_scores() {

+	/* App/Models/Order is better than App/MOdels/zRder  */

+	ASSERT(match("amor", "app/models/order") > match("amor", "app/models/zrder"));

+

+	/* App/MOdels/foo is better than App/M/fOo  */

+	ASSERT(match("amo", "app/m/foo") < match("amo", "app/models/foo"));

+

+	/* GEMFIle.Lock < GEMFILe  */

+	ASSERT(match("gemfil", "Gemfile.lock") < match("gemfil", "Gemfile"));

+

+	/* GEMFIle.Lock < GEMFILe  */

+	ASSERT(match("gemfil", "Gemfile.lock") < match("gemfil", "Gemfile"));

+

+	/* Prefer shorter matches */

+	ASSERT(match("abce", "abcdef") > match("abce", "abc de"));

+

+	/* Prefer shorter candidates */

+	ASSERT(match("test", "tests") > match("test", "testing"));

+

+	/* Scores first letter highly */

+	ASSERT(match("test", "testing") > match("test", "/testing"));

+

+	/* Prefer shorter matches */

+	ASSERT(match("abc", "    a b c ") > match("abc", " a  b  c "));

+	ASSERT(match("abc", " a b c    ") > match("abc", " a  b  c "));

+

+	PASS();

+}

+

+TEST test_exact_scores() {

+	/* Exact match is SCORE_MAX */

+	ASSERT_EQ(SCORE_MAX, match("abc", "abc"));

+	ASSERT_EQ(SCORE_MAX, match("aBc", "abC"));

+

+	/* Empty query always results in SCORE_MIN */

+	ASSERT_EQ(SCORE_MIN, match("", ""));

+	ASSERT_EQ(SCORE_MIN, match("", "a"));

+	ASSERT_EQ(SCORE_MIN, match("", "bb"));

+

+	/* Gaps */

+	ASSERT_EQ(SCORE_GAP_LEADING, match("a", "*a"));

+	ASSERT_EQ(SCORE_GAP_LEADING*2, match("a", "*ba"));

+	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_GAP_TRAILING, match("a", "**a*"));

+	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_GAP_TRAILING*2, match("a", "**a**"));

+	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CONSECUTIVE + SCORE_GAP_TRAILING*2, match("aa", "**aa**"));

+	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_GAP_TRAILING + SCORE_GAP_TRAILING, match("aa", "**a*a**"));

+

+	/* Consecutive */

+	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE, match("aa", "*aa"));

+	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE*2, match("aaa", "*aaa"));

+	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_CONSECUTIVE, match("aaa", "*a*aa"));

+

+	/* Slash */

+	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_SLASH, match("a", "/a"));

+	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_SLASH, match("a", "*/a"));

+	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_SLASH + SCORE_MATCH_CONSECUTIVE, match("aa", "a/aa"));

+

+	/* Capital */

+	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_CAPITAL, match("a", "bA"));

+	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CAPITAL, match("a", "baA"));

+	ASSERT_EQ(SCORE_GAP_LEADING*2 + SCORE_MATCH_CAPITAL + SCORE_MATCH_CONSECUTIVE, match("aa", "baAa"));

+

+	/* Dot */

+	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_MATCH_DOT, match("a", ".a"));

+	ASSERT_EQ(SCORE_GAP_LEADING*3 + SCORE_MATCH_DOT, match("a", "*a.a"));

+	ASSERT_EQ(SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_DOT, match("a", "*a.a"));

+

+	PASS();

+}

+

+TEST test_positions_1() {

+	size_t positions[3];

+	match_positions("amo", "app/models/foo", positions);

+	ASSERT_EQ(0, positions[0]);

+	ASSERT_EQ(4, positions[1]);

+	ASSERT_EQ(5, positions[2]);

+

+	PASS();

+}

+

+TEST test_positions_2() {

+	/*

+	 * We should prefer matching the 'o' in order, since it's the beginning

+	 * of a word.

+	 */

+	size_t positions[4];

+	match_positions("amor", "app/models/order", positions);

+	ASSERT_EQ(0, positions[0]);

+	ASSERT_EQ(4, positions[1]);

+	ASSERT_EQ(11, positions[2]);

+

+	PASS();

+}

+

+TEST test_positions_3() {

+	size_t positions[2];

+	match_positions("as", "tags", positions);

+	ASSERT_EQ(1, positions[0]);

+	ASSERT_EQ(3, positions[1]);

+

+	PASS();

+}

+

+TEST test_positions_4() {

+	size_t positions[2];

+	match_positions("as", "examples.txt", positions);

+	ASSERT_EQ(2, positions[0]);

+	ASSERT_EQ(7, positions[1]);

+

+	PASS();

+}

+

+TEST test_positions_5() {

+	size_t positions[3];

+	match_positions("abc", "a/a/b/c/c", positions);

+	ASSERT_EQ(2, positions[0]);

+	ASSERT_EQ(4, positions[1]);

+	ASSERT_EQ(6, positions[2]);

+

+	PASS();

+}

+

+TEST test_positions_exact() {

+	size_t positions[3];

+	match_positions("foo", "foo", positions);

+	ASSERT_EQ(0, positions[0]);

+	ASSERT_EQ(1, positions[1]);

+	ASSERT_EQ(2, positions[2]);

+

+	PASS();

+}

+

+SUITE(match_suite) {

+	RUN_TEST(test_match);

+	RUN_TEST(test_relative_scores);

+	RUN_TEST(test_exact_scores);

+	RUN_TEST(test_positions_1);

+	RUN_TEST(test_positions_2);

+	RUN_TEST(test_positions_3);

+	RUN_TEST(test_positions_4);

+	RUN_TEST(test_positions_5);

+	RUN_TEST(test_positions_exact);

+}