int file_tokenize()
{
int num_failed = 0;
corpus::document doc{"../data/sample-document.txt", doc_id{47}};
num_failed += testing::run_test("file-unigram-word-analyzer", [&]()
{
analyzers::ngram_word_analyzer tok{1, make_filter()};
check_analyzer_expected(tok, doc, 93, 168);
});
num_failed += testing::run_test("file-bigram-word-analyzer", [&]()
{
analyzers::ngram_word_analyzer tok{2, make_filter()};
check_analyzer_expected(tok, doc, 140, 167);
});
num_failed += testing::run_test("file-trigram-word-analyzer", [&]()
{
analyzers::ngram_word_analyzer tok{3, make_filter()};
check_analyzer_expected(tok, doc, 159, 166);
});
return num_failed;
}
int content_tokenize()
{
corpus::document doc{"/home/person/filename.txt", doc_id{47}};
// "one" is a stopword
std::string content = "one one two two two three four one five";
doc.content(content);
int num_failed = 0;
num_failed += testing::run_test("content-unigram-word-analyzer", [&]()
{
analyzers::ngram_word_analyzer tok{1, make_filter()};
check_analyzer_expected(tok, doc, 6, 8);
});
num_failed += testing::run_test("content-bigram-word-analyzer", [&]()
{
analyzers::ngram_word_analyzer tok{2, make_filter()};
check_analyzer_expected(tok, doc, 6, 7);
});
num_failed += testing::run_test("content-trigram-word-analyzer", [&]()
{
analyzers::ngram_word_analyzer tok{3, make_filter()};
check_analyzer_expected(tok, doc, 6, 6);
});
return num_failed;
}
static void test_composecolorfilter_limit(skiatest::Reporter* reporter) {
// Test that CreateComposeFilter() has some finite limit (i.e. that the factory can return null)
const int way_too_many = 100;
SkAutoTUnref<SkColorFilter> parent(make_filter());
for (int i = 2; i < way_too_many; ++i) {
SkAutoTUnref<SkColorFilter> filter(make_filter());
parent.reset(SkColorFilter::CreateComposeFilter(parent, filter));
if (NULL == parent) {
REPORTER_ASSERT(reporter, i > 2); // we need to have succeeded at least once!
return;
}
}
REPORTER_ASSERT(reporter, false); // we never saw a NULL :(
}
static VALUE t_make_filter(VALUE self, VALUE(left), VALUE(center), VALUE(right), VALUE(init_freq), VALUE(delta)) {
Carr *d = make_filter(NUM2DBL(left), NUM2DBL(center),
NUM2DBL(right), NUM2DBL(init_freq), NUM2DBL(delta));
if (d) {
VALUE result = rb_ary_new2(2);
rb_ary_store(result, 0, INT2FIX(round(d->data[0])));
int i;
VALUE filt = rb_ary_new2(d->rows-1);
for (i=1;i<d->rows;++i) {
rb_ary_store(filt, i-1, rb_float_new(d->data[i]));
}
rb_ary_store(result, 1, filt);
carr_free(d);
return result;
}
return Qnil;
}
/*----------------------------------------------------------------------------*/
System Surface::allocate_system()
{
const int n = 4*w*h;
const int m = w*h;
const long double w2 = (long double)(w)/2.;
const long double h2 = (long double)(h)/2.;
const long double sqrt_L1 = sqrtl(LAMBDA_1);
const long double sqrt_1ML1 = sqrtl(1.-LAMBDA_1);
const long double sqrt_L2 = sqrtl(LAMBDA_2);
// builds B
long double *b = new long double[n];
for(int u=0; u<w; u++)
for(int v=0; v<h; v++)
{
int i = u * h + v;
b[i] = sqrt_L1 * mu(u,v) * depth_map(u,v);
}
for(int i=m; i<n; i++)
b[i] = 0.;
Zvect *B = new Zvect(n, b);
// builds A
SparseMat *A = new SparseMat(n,m);
// part 1
for(int u=0; u<w; u++)
for(int v=0; v<h; v++)
{
int i = u * h + v;
A->add_coeff(i, i, sqrt_L1*mu(u,v));
}
// part 2
long double dx_filter[] = {-1./12., 0. , 1./12.,
-4./12., 0. , 4./12.,
-1./12., 0. , 1./12.};
for(int u=0; u<w; u++)
for(int v=0; v<h; v++)
{
int j = u * h + v;
int i = m + j;
long double x = ((long double)(u)-w2)/fx;
long double y = ((long double)(v)-h2)/fy;
const vec& n = caracs(u,v).n;
long double dx_weight = sqrt_1ML1 * (n[2] - (n[0]*x + n[1]*y));
A->add_row_coeff(i, make_filter(u,v, dx_filter, dx_weight));
A->add_coeff(i, j, -sqrt_1ML1 * n[0] / fx);
}
// part 3
long double dy_filter[] = { 1./12., 4./12. , 1./12.,
0., 0. , 0.,
-1./12., -4./12. , -1./12.,};
for(int u=0; u<w; u++)
for(int v=0; v<h; v++)
{
int j = u * h + v;
int i = 2*m + j;
long double x = ((long double)(u)-w2)/fx;
long double y = ((long double)(v)-h2)/fy;
const vec& n = caracs(u,v).n;
long double dy_weight = sqrt_1ML1 * (n[2] - (n[0]*x + n[1]*y));
A->add_row_coeff(i, make_filter(u,v, dy_filter, dy_weight));
A->add_coeff(i, j, -sqrt_1ML1 * n[1] / fy);
}
// part 4
long double laplacian_filter[] = { -1., -1. , -1.,
-1., 8. , -1.,
-1., -1. , -1.};
for(int u=0; u<w; u++)
for(int v=0; v<h; v++)
{
int i = 3*m + u * h + v;
A->add_row_coeff(i, make_filter(u,v, laplacian_filter, sqrt_L2));
}
return pair<SparseMat*, Zvect*>(A,B);
}
/* V_STRING -> V_FILTER */
static struct value *xform_excl(struct info *info, struct value *s) {
assert(s->tag == V_STRING);
struct value *v = make_value(V_FILTER, ref(info));
v->filter = make_filter(ref(s->string), 0);
return v;
}
dsEnqError srch_start()
{
struct ds_search_arg search_arg;
struct ds_search_result result;
struct DSError error;
dsEnqError return_error;
extern Filter make_filter();
DN curr_rdn;
if (*mvalue == '\0') {
return list_start();
}
if (get_default_service (&search_arg.sra_common) != 0) {
return nothingfound;
}
search_arg.sra_common.ca_servicecontrol.svc_options = SVC_OPT_PREFERCHAIN;
curr_rdn = search_arg.sra_baseobject = (*base_path != 'T'?
str2dn (base_path):
NULLDN);
search_arg.sra_eis.eis_allattributes = FALSE;
search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTETYPESONLY;
search_arg.sra_eis.eis_select = 0;
search_arg.sra_searchaliases = TRUE;
search_arg.sra_subset = SRA_ONELEVEL;
while (curr_rdn != NULLDN) {
if (!strcmp(curr_rdn->dn_rdn->rdn_at->oa_ot.ot_stroid,
"2.5.4.10")) {
search_arg.sra_subset = SRA_WHOLESUBTREE;
break;
}
curr_rdn = curr_rdn->dn_parent;
}
if ((search_arg.sra_filter = make_filter(filt_arr[typeindx])) == NULLFILTER)
return duaerror;
#ifndef NO_STATS
LLOG (log_stat, LLOG_NOTICE, ("search +%s, extent %d, val %s",
base_path,search_arg.sra_subset, mvalue));
#endif
if(ds_search (&search_arg, &error, &result) != DS_OK) {
/* deal with error */
free_seq(dnseq);
dnseq = NULLDS;
dn_number = 0;
log_ds_error(&error);
ds_error_free(&error);
switch (error.dse_type) {
case DSE_LOCALERROR:
return_error = duaerror;
break;
case DSE_REMOTEERROR:
return_error = localdsaerror;
break;
case DSE_ATTRIBUTEERROR:
return_error = attributerror;
break;
case DSE_REFERRAL:
case DSE_DSAREFERRAL:
return_error = remotedsaerror;
break;
case DSE_SECURITYERROR:
return_error = security;
break;
case DSE_NAMEERROR:
return_error = namerror;
break;
case DSE_SERVICEERROR:
return_error = serviceerror;
break;
default:
return_error = localdsaerror;
break;
}
} else {
correlate_search_results (&result);
dn_number = 0;
if (result.CSR_entries != NULLENTRYINFO) {
register EntryInfo *ptr;
return_error = Okay;
free_seq(dnseq);
dnseq = NULLDS;
dn_number = 0;
for (ptr = result.CSR_entries;
ptr != NULLENTRYINFO;
ptr = ptr->ent_next){
dn_number++;
dn2buf((caddr_t) ptr->ent_dn, goto_path);
add_seq(&dnseq, goto_path);
}
if (dn_number) dnseq = SortList(dnseq);
} else if (result.CSR_limitproblem == LSR_NOLIMITPROBLEM) {
free_seq(dnseq);
dnseq = NULLDS;
dn_number = 0;
return_error = nothingfound;
}
if(result.CSR_limitproblem != LSR_NOLIMITPROBLEM) {
switch (result.CSR_limitproblem) {
case LSR_TIMELIMITEXCEEDED:
if (dn_number > 0) return_error = timelimit_w_partial;
else {
free_seq(dnseq);
dnseq = NULLDS;
return_error = timelimit;
}
break;
case LSR_SIZELIMITEXCEEDED:
return_error = listsizelimit;
break;
case LSR_ADMINSIZEEXCEEDED:
if (dn_number > 0) return_error = adminlimit_w_partial;
else {
free_seq(dnseq);
dnseq = NULLDS;
return_error = adminlimit;
}
break;
}
entryinfo_free(result.CSR_entries, 0);
}
}
entry_number = dn_number;
filter_free(search_arg.sra_filter);
dn_free(search_arg.sra_baseobject);
ds_error_free(&error);
return return_error;
}
static array_header *get_sql_filters(pool *p, const char *query_name) {
register unsigned int i;
cmdtable *sql_cmdtab = NULL;
cmd_rec *sql_cmd = NULL;
modret_t *sql_res = NULL;
array_header *sql_data = NULL;
const char **values = NULL;
array_header *sql_filters = NULL;
sql_cmdtab = pr_stash_get_symbol2(PR_SYM_HOOK, "sql_lookup", NULL, NULL,
NULL);
if (sql_cmdtab == NULL) {
(void) pr_log_writefile(geoip_logfd, MOD_GEOIP_VERSION,
"unable to execute SQLNamedQuery '%s': mod_sql not loaded", query_name);
errno = EPERM;
return NULL;
}
sql_cmd = pr_cmd_alloc(p, 2, "sql_lookup", query_name);
sql_res = pr_module_call(sql_cmdtab->m, sql_cmdtab->handler, sql_cmd);
if (sql_res == NULL ||
MODRET_ISERROR(sql_res)) {
(void) pr_log_writefile(geoip_logfd, MOD_GEOIP_VERSION,
"error processing SQLNamedQuery '%s'; check mod_sql logs for details",
query_name);
errno = EPERM;
return NULL;
}
sql_data = sql_res->data;
pr_trace_msg(trace_channel, 9, "SQLNamedQuery '%s' returned item count %d",
query_name, sql_data->nelts);
if (sql_data->nelts == 0) {
(void) pr_log_writefile(geoip_logfd, MOD_GEOIP_VERSION,
"SQLNamedQuery '%s' returned no values", query_name);
errno = ENOENT;
return NULL;
}
if (sql_data->nelts % 2 == 1) {
(void) pr_log_writefile(geoip_logfd, MOD_GEOIP_VERSION,
"SQLNamedQuery '%s' returned odd number of values (%d), "
"expected even number", query_name, sql_data->nelts);
errno = EINVAL;
return NULL;
}
values = sql_data->elts;
sql_filters = make_array(p, 0, sizeof(struct geoip_filter));
for (i = 0; i < sql_data->nelts; i += 2) {
const char *filter_name, *pattern = NULL;
struct geoip_filter *filter;
filter_name = values[i];
pattern = values[i+1];
filter = make_filter(p, filter_name, pattern);
if (filter == NULL) {
pr_trace_msg(trace_channel, 3, "unable to use '%s %s' as filter: %s",
filter_name, pattern, strerror(errno));
continue;
}
*((struct geoip_filter **) push_array(sql_filters)) = filter;
}
return sql_filters;
}
