1
0
mirror of https://github.com/netsurf-browser/netsurf synced 2024-12-29 15:29:42 +03:00
netsurf/test/bloom.c
2016-08-14 23:32:20 +01:00

248 lines
4.7 KiB
C

/*
* Copyright 2015 Vincent Sanders <vince@netsurf-browser.org>
* Copyright 2013 Rob Kendrick <rjek@netsurf-browser.org>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
* NetSurf is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* NetSurf is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* \file
* Test bloom filter operations.
*
* Implementation taken from original test rig in bloom filter code
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <check.h>
#include "utils/bloom.h"
#define BLOOM_SIZE 8192
#define FALSE_POSITIVE_RATE 15 /* acceptable false positive percentage rate */
static struct bloom_filter *dict_bloom;
/* Fixtures */
/**
* create dictionary bloom
*
* bloom constructed from the first BLOOM_SIZE entries of the
* dictionary
*/
static void dict_bloom_create(void)
{
FILE *dictf;
char buf[BUFSIZ];
int i;
dictf = fopen("/usr/share/dict/words", "r");
ck_assert(dictf != NULL);
dict_bloom = bloom_create(BLOOM_SIZE);
ck_assert(dict_bloom != NULL);
for (i = 0; i < BLOOM_SIZE; i++) {
fscanf(dictf, "%s", buf);
bloom_insert_str(dict_bloom, buf, strlen(buf));
}
fclose(dictf);
}
static void dict_bloom_teardown(void)
{
bloom_destroy(dict_bloom);
}
/* Tests */
/**
* Test blooom filter creation
*
* Create a bloom filter, add a single entry and test for presece and
* absence of that entry (single entry cannot have false positives).
*
*/
START_TEST(bloom_create_test)
{
struct bloom_filter *b;
b = bloom_create(BLOOM_SIZE);
ck_assert(b != NULL);
bloom_insert_str(b, "NetSurf", 7);
ck_assert(bloom_search_str(b, "NetSurf", 7));
ck_assert(!bloom_search_str(b, "NotSurf", 7));
ck_assert(bloom_items(b) == 1);
bloom_destroy(b);
}
END_TEST
/**
* insert empty string test
*/
START_TEST(bloom_insert_empty_str_test)
{
struct bloom_filter *b;
b = bloom_create(BLOOM_SIZE);
ck_assert(b != NULL);
bloom_insert_str(b, NULL, 7);
ck_assert(bloom_items(b) == 1);
bloom_destroy(b);
}
END_TEST
/**
* Basic API creation test case
*/
static TCase *bloom_api_case_create(void)
{
TCase *tc;
tc = tcase_create("Creation");
tcase_add_test(tc, bloom_create_test);
tcase_add_test(tc, bloom_insert_empty_str_test);
return tc;
}
START_TEST(bloom_match_test)
{
FILE *dictf;
char buf[BUFSIZ];
int i;
dictf = fopen("/usr/share/dict/words", "r");
ck_assert(dictf != NULL);
for (i = 0; i < BLOOM_SIZE; i++) {
fscanf(dictf, "%s", buf);
ck_assert(bloom_search_str(dict_bloom, buf, strlen(buf)));
}
fclose(dictf);
}
END_TEST
/**
* Matching entry test case
*/
static TCase *bloom_match_case_create(void)
{
TCase *tc;
tc = tcase_create("Match");
tcase_add_checked_fixture(tc,
dict_bloom_create,
dict_bloom_teardown);
tcase_add_test(tc, bloom_match_test);
return tc;
}
START_TEST(bloom_falsepositive_test)
{
FILE *dictf;
char buf[BUFSIZ];
int i;
int false_positives = 0;
dictf = fopen("/usr/share/dict/words", "r");
ck_assert(dictf != NULL);
/* skip elements known presnent */
for (i = 0; i < BLOOM_SIZE; i++) {
fscanf(dictf, "%s", buf);
}
/* false positives are possible we are checking for low rate */
for (i = 0; i < BLOOM_SIZE; i++) {
fscanf(dictf, "%s", buf);
if (bloom_search_str(dict_bloom, buf, strlen(buf)) == true)
false_positives++;
}
fclose(dictf);
printf("false positive rate %d%%/%d%%\n",
(false_positives * 100)/BLOOM_SIZE,
FALSE_POSITIVE_RATE);
ck_assert(false_positives < ((BLOOM_SIZE * FALSE_POSITIVE_RATE) / 100));
}
END_TEST
/**
* Not matching test case
*/
static TCase *bloom_rate_case_create(void)
{
TCase *tc;
tc = tcase_create("False positive rate");
tcase_add_checked_fixture(tc,
dict_bloom_create,
dict_bloom_teardown);
tcase_add_test(tc, bloom_falsepositive_test);
return tc;
}
static Suite *bloom_suite(void)
{
Suite *s;
s = suite_create("Bloom filter");
suite_add_tcase(s, bloom_api_case_create());
suite_add_tcase(s, bloom_match_case_create());
suite_add_tcase(s, bloom_rate_case_create());
return s;
}
int main(int argc, char **argv)
{
int number_failed;
Suite *s;
SRunner *sr;
s = bloom_suite();
sr = srunner_create(s);
srunner_run_all(sr, CK_ENV);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}