TEST(lru_unlearner, max_size_must_be_positive) {
lru_unlearner::config config;
config.max_size = -1;
EXPECT_THROW(lru_unlearner unlearner(config), common::config_exception);
config.max_size = 0;
EXPECT_THROW(lru_unlearner unlearner(config), common::config_exception);
}
TEST(lru_unlearner, trivial) {
lru_unlearner::config config;
config.max_size = 3;
lru_unlearner unlearner(config);
mock_callback callback;
unlearner.set_callback(callback);
std::vector<std::string> touch_sequence;
touch_sequence.push_back("id1");
touch_sequence.push_back("id2");
touch_sequence.push_back("id3");
touch_sequence.push_back("id2");
touch_sequence.push_back("id1");
for (size_t i = 0; i < touch_sequence.size(); ++i) {
unlearner.touch(touch_sequence[i]);
EXPECT_EQ("", callback.unlearned_id());
EXPECT_TRUE(unlearner.exists_in_memory(touch_sequence[i]));
}
unlearner.touch("id4");
EXPECT_EQ("id3", callback.unlearned_id());
EXPECT_FALSE(unlearner.exists_in_memory(callback.unlearned_id()));
}
TEST(random_unlearner, remove) {
random_unlearner::config config;
config.max_size = 3;
random_unlearner unlearner(config);
// add 3 IDs
unlearner.touch("id1");
unlearner.touch("id2");
unlearner.touch("id3");
// remove the middle ID
EXPECT_TRUE(unlearner.remove("id2"));
EXPECT_TRUE(unlearner.exists_in_memory("id1"));
EXPECT_FALSE(unlearner.exists_in_memory("id2"));
EXPECT_TRUE(unlearner.exists_in_memory("id3"));
// add 1 ID
EXPECT_TRUE(unlearner.touch("id4"));
EXPECT_TRUE(unlearner.exists_in_memory("id1"));
EXPECT_FALSE(unlearner.exists_in_memory("id2"));
EXPECT_TRUE(unlearner.exists_in_memory("id3"));
EXPECT_TRUE(unlearner.exists_in_memory("id4"));
// remove the last ID
EXPECT_TRUE(unlearner.remove("id4"));
EXPECT_TRUE(unlearner.exists_in_memory("id1"));
EXPECT_FALSE(unlearner.exists_in_memory("id2"));
EXPECT_TRUE(unlearner.exists_in_memory("id3"));
EXPECT_FALSE(unlearner.exists_in_memory("id4"));
// remove non-existent ID
EXPECT_FALSE(unlearner.remove("foo"));
EXPECT_FALSE(unlearner.remove("id4"));
}
shared_ptr<anomaly_base> anomaly_factory::create_anomaly(
const string& name,
const config& param,
const string& id) {
if (name == "lof") {
lof_config conf = config_cast_check<lof_config>(param);
return shared_ptr<anomaly_base>(new lof(
conf,
recommender::recommender_factory::create_recommender(
conf.method,
conf.parameter, id)));
} else if (name == "light_lof") {
light_lof_config conf = config_cast_check<light_lof_config>(param);
jubatus::util::lang::shared_ptr<table::column_table> nearest_neighbor_table(
new table::column_table);
jubatus::util::lang::shared_ptr<nearest_neighbor::nearest_neighbor_base>
nearest_neighbor_engine(nearest_neighbor::create_nearest_neighbor(
conf.method, conf.parameter, nearest_neighbor_table, id));
if (conf.unlearner) {
if (!conf.unlearner_parameter) {
throw JUBATUS_EXCEPTION(
common::config_exception()
<< common::exception::error_message(
"unlearner is set but unlearner_parameter is not found"));
}
jubatus::util::lang::shared_ptr<unlearner::unlearner_base> unlearner(
unlearner::create_unlearner(
*conf.unlearner,
*conf.unlearner_parameter));
return shared_ptr<anomaly_base>(
new light_lof(conf, id, nearest_neighbor_engine, unlearner));
}
return jubatus::util::lang::shared_ptr<anomaly_base>(
new light_lof(conf, id, nearest_neighbor_engine));
} else {
throw JUBATUS_EXCEPTION(common::unsupported_method(name));
}
};
void SetUp() {
core::anomaly::light_lof::config lof_config;
lof_config.nearest_neighbor_num = 3;
lof_config.reverse_nearest_neighbor_num = 3;
shared_ptr<table::column_table> lsh_table(
new table::column_table);
core::nearest_neighbor::euclid_lsh::config lsh_config;
shared_ptr<core::nearest_neighbor::nearest_neighbor_base> lsh(
new core::nearest_neighbor::euclid_lsh(lsh_config, lsh_table, "id"));
unlearner::lru_unlearner::config unlearner_config;
unlearner_config.max_size = 5;
jubatus::util::lang::shared_ptr<unlearner::unlearner_base> unlearner(
new unlearner::lru_unlearner(unlearner_config));
anomaly_.reset(new anomaly(
shared_ptr<anomaly_base>(
new core::anomaly::light_lof(
lof_config, "id", lsh, unlearner)),
make_fv_converter()));
}
TEST(random_unlearner, trivial) {
unordered_set<std::string> keys;
keys.insert("id1");
keys.insert("id2");
keys.insert("id3");
random_unlearner::config config;
config.max_size = 3;
random_unlearner unlearner(config);
mock_callback callback;
unlearner.set_callback(callback);
for (unordered_set<std::string>::iterator it = keys.begin();
it != keys.end(); ++it) {
unlearner.touch(*it);
EXPECT_EQ("", callback.unlearned_id());
EXPECT_TRUE(unlearner.exists_in_memory(*it));
}
unlearner.touch("last");
EXPECT_EQ(1ul, keys.count(callback.unlearned_id()));
EXPECT_FALSE(unlearner.exists_in_memory(callback.unlearned_id()));
}
TEST(random_unlearner, seed_must_be_within_32bit) {
random_unlearner::config config;
config.max_size = 1;
config.seed = 0xffffffffLLU + 1;
EXPECT_THROW(random_unlearner unlearner(config), common::config_exception);
}
TEST(random_unlearner, seed_must_positive) {
random_unlearner::config config;
config.max_size = 1;
config.seed = -1;
EXPECT_THROW(random_unlearner unlearner(config), common::config_exception);
}
