@@ -1,353 +1,17 @@

-#define _GNU_SOURCE

-#include <stdlib.h>

-#include <signal.h>

-#include <stdio.h>

-#include <string.h>

-

-#include "../config.h"

-#include "match.h"

-#include "choices.h"

-#include "options.h"

-

 #include "greatest/greatest.h"

-static options_t default_options;

-

-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();

-}

-

-TEST test_choices_empty() {

-	choices_t choices;

-	choices_init(&choices, &default_options);

-	ASSERT_EQ(0, choices.size);

-	ASSERT_EQ(0, choices.available);

-	ASSERT_EQ(0, choices.selection);

-

-	choices_prev(&choices);

-	ASSERT_EQ(0, choices.selection);

-

-	choices_next(&choices);

-	ASSERT_EQ(0, choices.selection);

-

-	choices_destroy(&choices);

-

-	PASS();

-}

-

-TEST test_choices_1() {

-	choices_t choices;

-	choices_init(&choices, &default_options);

-	choices_add(&choices, "tags");

-

-	choices_search(&choices, "");

-	ASSERT_EQ(1, choices.available);

-	ASSERT_EQ(0, choices.selection);

-

-	choices_search(&choices, "t");

-	ASSERT_EQ(1, choices.available);

-	ASSERT_EQ(0, choices.selection);

-

-	choices_prev(&choices);

-	ASSERT_EQ(0, choices.selection);

-

-	choices_next(&choices);

-	ASSERT_EQ(0, choices.selection);

-

-	ASSERT(!strcmp(choices_get(&choices, 0), "tags"));

-	ASSERT_EQ(NULL, choices_get(&choices, 1));

-

-	choices_destroy(&choices);

-

-	PASS();

-}

-

-TEST test_choices_2() {

-	choices_t choices;

-	choices_init(&choices, &default_options);

-	choices_add(&choices, "tags");

-	choices_add(&choices, "test");

-

-	/* Empty search */

-	choices_search(&choices, "");

-	ASSERT_EQ(0, choices.selection);

-	ASSERT_EQ(2, choices.available);

-

-	choices_next(&choices);

-	ASSERT_EQ(1, choices.selection);

-	choices_next(&choices);

-	ASSERT_EQ(0, choices.selection);

-

-	choices_prev(&choices);

-	ASSERT_EQ(1, choices.selection);

-	choices_prev(&choices);

-	ASSERT_EQ(0, choices.selection);

-

-	/* Filtered search */

-	choices_search(&choices, "te");

-	ASSERT_EQ(1, choices.available);

-	ASSERT_EQ(0, choices.selection);

-	ASSERT_STR_EQ("test", choices_get(&choices, 0));

-

-	choices_next(&choices);

-	ASSERT_EQ(0, choices.selection);

-

-	choices_prev(&choices);

-	ASSERT_EQ(0, choices.selection);

-

-	/* No results */

-	choices_search(&choices, "foobar");

-	ASSERT_EQ(0, choices.available);

-	ASSERT_EQ(0, choices.selection);

-

-	/* Different order due to scoring */

-	choices_search(&choices, "ts");

-	ASSERT_EQ(2, choices.available);

-	ASSERT_EQ(0, choices.selection);

-	ASSERT_STR_EQ("test", choices_get(&choices, 0));

-	ASSERT_STR_EQ("tags", choices_get(&choices, 1));

-

-	choices_destroy(&choices);

-

-	PASS();

-}

-

-TEST test_choices_without_search() {

-	/* Before a search is run, it should return no results */

-

-	choices_t choices;

-	choices_init(&choices, &default_options);

-

-	ASSERT_EQ(0, choices.available);

-	ASSERT_EQ(0, choices.selection);

-	ASSERT_EQ(0, choices.size);

-	ASSERT_EQ(NULL, choices_get(&choices, 0));

-

-	choices_add(&choices, "test");

-

-	ASSERT_EQ(0, choices.available);

-	ASSERT_EQ(0, choices.selection);

-	ASSERT_EQ(1, choices.size);

-	ASSERT_EQ(NULL, choices_get(&choices, 0));

-

-	choices_destroy(&choices);

-

-	PASS();

-}

-

-/* Regression test for segfault */

-TEST test_choices_unicode() {

-	choices_t choices;

-	choices_init(&choices, &default_options);

-

-	choices_add(&choices, "Edmund Husserl - Méditations cartésiennes - Introduction a la phénoménologie.pdf");

-	choices_search(&choices, "e");

-

-	choices_destroy(&choices);

-	PASS();

-}

-

-TEST test_choices_large_input() {

-	choices_t choices;

-	choices_init(&choices, &default_options);

-

-	int N = 100000;

-	char *strings[N];

-

-	for(int i = 0; i < N; i++) {

-		asprintf(&strings[i], "%i", i);

-		choices_add(&choices, strings[i]);

-	}

-

-	choices_search(&choices, "12");

-

-	/* Must match `seq 0 99999 | grep '.*1.*2.*' | wc -l` */

-	ASSERT_EQ(8146, choices.available);

-

-	ASSERT_STR_EQ("12", choices_get(&choices, 0));

-

-	for(int i = 0; i < N; i++) {

-		free(strings[i]);

-	}

-

-	choices_destroy(&choices);

-

-	PASS();

-}

-

-SUITE(properties);

+SUITE(match_suite);

+SUITE(choices_suite);

+SUITE(properties_suite);

 GREATEST_MAIN_DEFS();

 int main(int argc, char *argv[]) {

 	GREATEST_MAIN_BEGIN();

-	options_init(&default_options);

-

-	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(test_choices_empty);

-	RUN_TEST(test_choices_1);

-	RUN_TEST(test_choices_2);

-	RUN_TEST(test_choices_without_search);

-	RUN_TEST(test_choices_unicode);

-	RUN_TEST(test_choices_large_input);

-

-	RUN_SUITE(properties);

+	RUN_SUITE(match_suite);

+	RUN_SUITE(choices_suite);

+	RUN_SUITE(properties_suite);

 	GREATEST_MAIN_END();

 }

@@ -321,6 +321,8 @@ TEST test_choices_large_input() {

 	PASS();

 }

+SUITE(properties);

+

 GREATEST_MAIN_DEFS();

 int main(int argc, char *argv[]) {

@@ -345,5 +347,7 @@ int main(int argc, char *argv[]) {

 	RUN_TEST(test_choices_unicode);

 	RUN_TEST(test_choices_large_input);

+	RUN_SUITE(properties);

+

 	GREATEST_MAIN_END();

 }

@@ -62,41 +62,41 @@ TEST test_relative_scores() {

 TEST test_exact_scores() {

 	/* Exact match is SCORE_MAX */

-	ASSERT(match("abc", "abc") == SCORE_MAX);

-	ASSERT(match("aBc", "abC") == SCORE_MAX);

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

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

 	/* Empty query always results in SCORE_MIN */

-	ASSERT(match("", "") == SCORE_MIN);

-	ASSERT(match("", "a") == SCORE_MIN);

-	ASSERT(match("", "bb") == SCORE_MIN);

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

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

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

 	/* Gaps */

-	ASSERT(match("a", "*a") == SCORE_GAP_LEADING);

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

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

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

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

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

+	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(match("aa", "*aa") == SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE);

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

-	ASSERT(match("aaa", "*a*aa") == SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_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(match("a", "/a") == SCORE_GAP_LEADING + SCORE_MATCH_SLASH);

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

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

+	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(match("a", "bA") == SCORE_GAP_LEADING + SCORE_MATCH_CAPITAL);

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

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

+	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(match("a", ".a") == SCORE_GAP_LEADING + SCORE_MATCH_DOT);

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

-	ASSERT(match("a", "*a.a") == SCORE_GAP_LEADING + SCORE_GAP_INNER + SCORE_MATCH_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();

 }

@@ -104,9 +104,9 @@ TEST test_exact_scores() {

 TEST test_positions_1() {

 	size_t positions[3];

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

-	ASSERT(positions[0] == 0);

-	ASSERT(positions[1] == 4);

-	ASSERT(positions[2] == 5);

+	ASSERT_EQ(0, positions[0]);

+	ASSERT_EQ(4, positions[1]);

+	ASSERT_EQ(5, positions[2]);

 	PASS();

 }

@@ -118,9 +118,9 @@ TEST test_positions_2() {

 	 */

 	size_t positions[4];

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

-	ASSERT(positions[0] == 0);

-	ASSERT(positions[1] == 4);

-	ASSERT(positions[2] == 11);

+	ASSERT_EQ(0, positions[0]);

+	ASSERT_EQ(4, positions[1]);

+	ASSERT_EQ(11, positions[2]);

 	PASS();

 }

@@ -128,8 +128,8 @@ TEST test_positions_2() {

 TEST test_positions_3() {

 	size_t positions[2];

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

-	ASSERT(positions[0] == 1);

-	ASSERT(positions[1] == 3);

+	ASSERT_EQ(1, positions[0]);

+	ASSERT_EQ(3, positions[1]);

 	PASS();

 }

@@ -137,8 +137,8 @@ TEST test_positions_3() {

 TEST test_positions_4() {

 	size_t positions[2];

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

-	ASSERT(positions[0] == 2);

-	ASSERT(positions[1] == 7);

+	ASSERT_EQ(2, positions[0]);

+	ASSERT_EQ(7, positions[1]);

 	PASS();

 }

@@ -146,9 +146,9 @@ TEST test_positions_4() {

 TEST test_positions_5() {

 	size_t positions[3];

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

-	ASSERT(positions[0] == 2);

-	ASSERT(positions[1] == 4);

-	ASSERT(positions[2] == 6);

+	ASSERT_EQ(2, positions[0]);

+	ASSERT_EQ(4, positions[1]);

+	ASSERT_EQ(6, positions[2]);

 	PASS();

 }

@@ -156,9 +156,9 @@ TEST test_positions_5() {

 TEST test_positions_exact() {

 	size_t positions[3];

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

-	ASSERT(positions[0] == 0);

-	ASSERT(positions[1] == 1);

-	ASSERT(positions[2] == 2);

+	ASSERT_EQ(0, positions[0]);

+	ASSERT_EQ(1, positions[1]);

+	ASSERT_EQ(2, positions[2]);

 	PASS();

 }

@@ -166,15 +166,15 @@ TEST test_positions_exact() {

 TEST test_choices_empty() {

 	choices_t choices;

 	choices_init(&choices, &default_options);

-	ASSERT(choices.size == 0);

-	ASSERT(choices.available == 0);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(0, choices.size);

+	ASSERT_EQ(0, choices.available);

+	ASSERT_EQ(0, choices.selection);

 	choices_prev(&choices);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(0, choices.selection);

 	choices_next(&choices);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(0, choices.selection);

 	choices_destroy(&choices);

@@ -187,21 +187,21 @@ TEST test_choices_1() {

 	choices_add(&choices, "tags");

 	choices_search(&choices, "");

-	ASSERT(choices.available == 1);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(1, choices.available);

+	ASSERT_EQ(0, choices.selection);

 	choices_search(&choices, "t");

-	ASSERT(choices.available == 1);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(1, choices.available);

+	ASSERT_EQ(0, choices.selection);

 	choices_prev(&choices);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(0, choices.selection);

 	choices_next(&choices);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(0, choices.selection);

 	ASSERT(!strcmp(choices_get(&choices, 0), "tags"));

-	ASSERT(choices_get(&choices, 1) == NULL);

+	ASSERT_EQ(NULL, choices_get(&choices, 1));

 	choices_destroy(&choices);

@@ -216,40 +216,40 @@ TEST test_choices_2() {

 	/* Empty search */

 	choices_search(&choices, "");

-	ASSERT(choices.selection == 0);

-	ASSERT(choices.available == 2);

+	ASSERT_EQ(0, choices.selection);

+	ASSERT_EQ(2, choices.available);

 	choices_next(&choices);

-	ASSERT(choices.selection == 1);

+	ASSERT_EQ(1, choices.selection);

 	choices_next(&choices);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(0, choices.selection);

 	choices_prev(&choices);

-	ASSERT(choices.selection == 1);

+	ASSERT_EQ(1, choices.selection);

 	choices_prev(&choices);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(0, choices.selection);

 	/* Filtered search */

 	choices_search(&choices, "te");

-	ASSERT(choices.available == 1);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(1, choices.available);

+	ASSERT_EQ(0, choices.selection);

 	ASSERT_STR_EQ("test", choices_get(&choices, 0));

 	choices_next(&choices);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(0, choices.selection);

 	choices_prev(&choices);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(0, choices.selection);

 	/* No results */

 	choices_search(&choices, "foobar");

-	ASSERT(choices.available == 0);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(0, choices.available);

+	ASSERT_EQ(0, choices.selection);

 	/* Different order due to scoring */

 	choices_search(&choices, "ts");

-	ASSERT(choices.available == 2);

-	ASSERT(choices.selection == 0);

+	ASSERT_EQ(2, choices.available);

+	ASSERT_EQ(0, choices.selection);

 	ASSERT_STR_EQ("test", choices_get(&choices, 0));

 	ASSERT_STR_EQ("tags", choices_get(&choices, 1));

@@ -264,17 +264,17 @@ TEST test_choices_without_search() {

 	choices_t choices;

 	choices_init(&choices, &default_options);

-	ASSERT(choices.available == 0);

-	ASSERT(choices.selection == 0);

-	ASSERT(choices.size == 0);

-	ASSERT(choices_get(&choices, 0) == NULL);

+	ASSERT_EQ(0, choices.available);

+	ASSERT_EQ(0, choices.selection);

+	ASSERT_EQ(0, choices.size);

+	ASSERT_EQ(NULL, choices_get(&choices, 0));

 	choices_add(&choices, "test");

-	ASSERT(choices.available == 0);

-	ASSERT(choices.selection == 0);

-	ASSERT(choices.size == 1);

-	ASSERT(choices_get(&choices, 0) == NULL);

+	ASSERT_EQ(0, choices.available);

+	ASSERT_EQ(0, choices.selection);

+	ASSERT_EQ(1, choices.size);

+	ASSERT_EQ(NULL, choices_get(&choices, 0));

 	choices_destroy(&choices);

@@ -308,7 +308,7 @@ TEST test_choices_large_input() {

 	choices_search(&choices, "12");

 	/* Must match `seq 0 99999 | grep '.*1.*2.*' | wc -l` */

-	ASSERT(choices.available == 8146);

+	ASSERT_EQ(8146, choices.available);

 	ASSERT_STR_EQ("12", choices_get(&choices, 0));

@@ -233,7 +233,7 @@ TEST test_choices_2() {

 	choices_search(&choices, "te");

 	ASSERT(choices.available == 1);

 	ASSERT(choices.selection == 0);

-	ASSERT_STR_EQ(choices_get(&choices, 0), "test");

+	ASSERT_STR_EQ("test", choices_get(&choices, 0));

 	choices_next(&choices);

 	ASSERT(choices.selection == 0);

@@ -250,8 +250,8 @@ TEST test_choices_2() {

 	choices_search(&choices, "ts");

 	ASSERT(choices.available == 2);

 	ASSERT(choices.selection == 0);

-	ASSERT_STR_EQ(choices_get(&choices, 0), "test");

-	ASSERT_STR_EQ(choices_get(&choices, 1), "tags");

+	ASSERT_STR_EQ("test", choices_get(&choices, 0));

+	ASSERT_STR_EQ("tags", choices_get(&choices, 1));

 	choices_destroy(&choices);

@@ -310,7 +310,7 @@ TEST test_choices_large_input() {

 	/* Must match `seq 0 99999 | grep '.*1.*2.*' | wc -l` */

 	ASSERT(choices.available == 8146);

-	ASSERT_STR_EQ(choices_get(&choices, 0), "12");

+	ASSERT_STR_EQ("12", choices_get(&choices, 0));

 	for(int i = 0; i < N; i++) {

 		free(strings[i]);

@@ -9,200 +9,206 @@

 #include "choices.h"

 #include "options.h"

-int testsrun = 0, testsfailed = 0, assertionsrun = 0;

-

-#define assert(x)                                                                                  \

-	if (++assertionsrun && !(x)) {                                                             \

-		fprintf(stderr, "test \"%s\" failed\n   assert(%s) was false\n   at %s:%i\n\n",    \

-			__func__, #x, __FILE__, __LINE__);                                         \

-		raise(SIGTRAP);                                                                    \

-		testsfailed++;                                                                     \

-		return;                                                                            \

-	}

-

-#define assert_streq(a, b) assert(!strcmp(a, b))

+#include "greatest/greatest.h"

 static options_t default_options;

-void runtest(void (*test)()) {

-	testsrun++;

-	test();

-}

-

-void test_match() {

-	assert(has_match("a", "a"));

-	assert(has_match("a", "ab"));

-	assert(has_match("a", "ba"));

-	assert(has_match("abc", "a|b|c"));

+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"));

+	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"));

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

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

+

+	PASS();

 }

-void test_relative_scores() {

+TEST test_relative_scores() {

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

-	assert(match("amor", "app/models/order") > match("amor", "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"));

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

 	/* GEMFIle.Lock < GEMFILe  */

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

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

 	/* GEMFIle.Lock < GEMFILe  */

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

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

 	/* Prefer shorter matches */

-	assert(match("abce", "abcdef") > match("abce", "abc de"));

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

 	/* Prefer shorter candidates */

-	assert(match("test", "tests") > match("test", "testing"));

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

 	/* Scores first letter highly */

-	assert(match("test", "testing") > match("test", "/testing"));

+	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 "));

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

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

+

+	PASS();

 }

-void test_exact_scores() {

+TEST test_exact_scores() {

 	/* Exact match is SCORE_MAX */

-	assert(match("abc", "abc") == SCORE_MAX);

-	assert(match("aBc", "abC") == SCORE_MAX);

+	ASSERT(match("abc", "abc") == SCORE_MAX);

+	ASSERT(match("aBc", "abC") == SCORE_MAX);

 	/* Empty query always results in SCORE_MIN */

-	assert(match("", "") == SCORE_MIN);

-	assert(match("", "a") == SCORE_MIN);

-	assert(match("", "bb") == SCORE_MIN);

+	ASSERT(match("", "") == SCORE_MIN);

+	ASSERT(match("", "a") == SCORE_MIN);

+	ASSERT(match("", "bb") == SCORE_MIN);

 	/* Gaps */

-	assert(match("a", "*a") == SCORE_GAP_LEADING);

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

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

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

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

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

+	ASSERT(match("a", "*a") == SCORE_GAP_LEADING);

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

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

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

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

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

 	/* Consecutive */

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

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

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

+	ASSERT(match("aa", "*aa") == SCORE_GAP_LEADING + SCORE_MATCH_CONSECUTIVE);

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

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

 	/* Slash */

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

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

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

+	ASSERT(match("a", "/a") == SCORE_GAP_LEADING + SCORE_MATCH_SLASH);

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

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

 	/* Capital */

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

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

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

+	ASSERT(match("a", "bA") == SCORE_GAP_LEADING + SCORE_MATCH_CAPITAL);

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

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

 	/* Dot */

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

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

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

+	ASSERT(match("a", ".a") == SCORE_GAP_LEADING + SCORE_MATCH_DOT);

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

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

+

+	PASS();

 }

-void test_positions_1() {

+TEST test_positions_1() {

 	size_t positions[3];

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

-	assert(positions[0] == 0);

-	assert(positions[1] == 4);

-	assert(positions[2] == 5);

+	ASSERT(positions[0] == 0);

+	ASSERT(positions[1] == 4);

+	ASSERT(positions[2] == 5);

+

+	PASS();

 }

-void test_positions_2() {

+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(positions[0] == 0);

-	assert(positions[1] == 4);

-	assert(positions[2] == 11);

+	ASSERT(positions[0] == 0);

+	ASSERT(positions[1] == 4);

+	ASSERT(positions[2] == 11);

+

+	PASS();

 }

-void test_positions_3() {

+TEST test_positions_3() {

 	size_t positions[2];

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

-	assert(positions[0] == 1);

-	assert(positions[1] == 3);