DECLARE_TEST( event, immediate )
{
event_stream_t* stream;
event_block_t* block;
event_t* event;
uint16_t last_serial = 0;
uint8_t buffer[128] = {0};
stream = event_stream_allocate( 0 );
event_post( stream, FOUNDATIONEVENT_TERMINATE, 0, 0, 0, 0 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_NE( event, 0 );
EXPECT_EQ( event->id, FOUNDATIONEVENT_TERMINATE );
EXPECT_EQ( event->size, sizeof( event_t ) );
EXPECT_GT( event->serial, last_serial );
EXPECT_EQ( event->object, 0 );
EXPECT_EQ( event->flags, 0 );
EXPECT_EQ( event_payload_size( event ), 0 );
last_serial = event->serial;
event = event_next( block, event );
EXPECT_EQ( event, 0 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_EQ( event, 0 );
event = event_next( block, event );
EXPECT_EQ( event, 0 );
event_post( stream, FOUNDATIONEVENT_TERMINATE, 13, 0, buffer, 0 );
event_post( stream, FOUNDATIONEVENT_TERMINATE + 1, 37, 0, buffer, 0 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_NE( event, 0 );
EXPECT_EQ( event->id, FOUNDATIONEVENT_TERMINATE );
EXPECT_EQ( event->size, sizeof( event_t ) + 16 );
EXPECT_GT( event->serial, last_serial );
EXPECT_EQ( event->object, 0 );
EXPECT_EQ( event->flags, 0 );
EXPECT_EQ( event_payload_size( event ), 16 );
last_serial = event->serial;
event = event_next( block, event );
EXPECT_NE( event, 0 );
EXPECT_EQ( event->id, FOUNDATIONEVENT_TERMINATE + 1 );
EXPECT_EQ( event->size, sizeof( event_t ) + 40 );
EXPECT_GT( event->serial, last_serial );
EXPECT_EQ( event->object, 0 );
EXPECT_EQ( event->flags, 0 );
EXPECT_EQ( event_payload_size( event ), 40 );
last_serial = event->serial;
event_stream_deallocate( stream );
return 0;
}
TEST_F(Platform, Whitespace_strlen) {
for (int i = 0; i < kTrialCount; i++) {
size_t l = strlen(whitespace_);
EXPECT_GT(l, whitespace_length_);
}
}
TEST_F(Pr2SBPLPlannerTester, HardPlan3)
{
planning_scene::PlanningScenePtr ps(new planning_scene::PlanningScene());
ps->setActiveCollisionDetector(collision_detection::CollisionDetectorAllocatorHybridROS::create());
ps->configure(rml_->getURDF(), rml_->getSRDF());
ASSERT_TRUE(ps->isConfigured());
ps->getAllowedCollisionMatrixNonConst() = *acm_;
planning_models::RobotState *::JointStateGroup* start_jsg = ps->getCurrentState().getJointStateGroup("right_arm");
std::vector<double> start_vals(7);
start_vals[0] = -.785163;
start_vals[1] = -.346628;
start_vals[2] = -2.36346;
start_vals[3] = -0.204096;
start_vals[4] = -1.75754;
start_vals[5] = -0.771607;
start_vals[6] = 1.67731;
start_jsg->setStateValues(start_vals);
sbpl_interface::SBPLInterface sbpl_planner(ps->getRobotModel());
moveit_msgs::GetMotionPlan::Request mplan_req;
moveit_msgs::GetMotionPlan::Response mplan_res;
mplan_req.motion_plan_request.group_name = "right_arm";
mplan_req.motion_plan_request.num_planning_attempts = 5;
mplan_req.motion_plan_request.allowed_planning_time = ros::Duration(5.0);
const std::vector<std::string>& joint_names = ps->getRobotModel()->getJointModelGroup("right_arm")->getJointModelNames();
mplan_req.motion_plan_request.goal_constraints.resize(1);
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints.resize(joint_names.size());
for(unsigned int i = 0; i < joint_names.size(); i++)
{
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[i].joint_name = joint_names[i];
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[i].position = 0.0;
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[i].tolerance_above = 0.001;
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[i].tolerance_below = 0.001;
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[i].weight = 1.0;
}
std::vector<double> goal_vals(7);
goal_vals[0] = -1.78778;
goal_vals[1] = 0.749619;
goal_vals[2] = 0.594005;
goal_vals[3] = -1.83274;
goal_vals[4] = 1.5158;
goal_vals[5] = -.500754;
goal_vals[6] = -.108037;
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[0].position = goal_vals[0];
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[1].position = goal_vals[1];
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[2].position = goal_vals[2];
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[3].position = goal_vals[3];
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[4].position = goal_vals[4];
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[5].position = goal_vals[5];
mplan_req.motion_plan_request.goal_constraints[0].joint_constraints[6].position = goal_vals[6];
sbpl_planner.solve(ps,
mplan_req,
mplan_res);
ASSERT_EQ(mplan_res.error_code.val, mplan_res.error_code.SUCCESS);
EXPECT_GT(mplan_res.trajectory.joint_trajectory.points.size(), 0);
}
TEST( BinaryAssertions, EXPECT_GT )
{
EXPECT_GT( 3, 2 ); // expectd > actual なら成功
EXPECT_GT( 4, 4 ); // expectd == actual なら失敗
EXPECT_GT( 4, 5 ); // expectd < actual なら失敗
}
int get_groups(const char *cmd) {
FILE *fp;
// NB: crash log only available in user space
EXPECT_TRUE(NULL != (fp = popen(cmd, "r")));
if (fp == NULL) {
return 0;
}
char buffer[BIG_BUFFER];
int count = 0;
while (fgets(buffer, sizeof(buffer), fp)) {
int size, consumed, max, payload;
char size_mult[3], consumed_mult[3];
long full_size, full_consumed;
size = consumed = max = payload = 0;
// NB: crash log can be very small, not hit a Kb of consumed space
// doubly lucky we are not including it.
if (6 != sscanf(buffer, "%*s ring buffer is %d%2s (%d%2s consumed),"
" max entry is %db, max payload is %db",
&size, size_mult, &consumed, consumed_mult,
&max, &payload)) {
fprintf(stderr, "WARNING: Parse error: %s", buffer);
continue;
}
full_size = size;
switch(size_mult[0]) {
case 'G':
full_size *= 1024;
/* FALLTHRU */
case 'M':
full_size *= 1024;
/* FALLTHRU */
case 'K':
full_size *= 1024;
/* FALLTHRU */
case 'b':
break;
}
full_consumed = consumed;
switch(consumed_mult[0]) {
case 'G':
full_consumed *= 1024;
/* FALLTHRU */
case 'M':
full_consumed *= 1024;
/* FALLTHRU */
case 'K':
full_consumed *= 1024;
/* FALLTHRU */
case 'b':
break;
}
EXPECT_GT((full_size * 9) / 4, full_consumed);
EXPECT_GT(full_size, max);
EXPECT_GT(max, payload);
if ((((full_size * 9) / 4) >= full_consumed)
&& (full_size > max)
&& (max > payload)) {
++count;
}
}
pclose(fp);
return count;
}
TEST(TestHaierACClass, Timers) {
IRHaierAC haier(0);
haier.begin();
haier.setCommand(HAIER_AC_CMD_ON);
// Off by default.
EXPECT_GT(0, haier.getOnTimer());
EXPECT_GT(0, haier.getOffTimer());
EXPECT_EQ(HAIER_AC_CMD_ON, haier.getCommand());
// On Timer.
haier.setOnTimer(6 * 60); // 6am
EXPECT_EQ(6 * 60, haier.getOnTimer()); // 6am
EXPECT_GT(0, haier.getOffTimer());
EXPECT_EQ(HAIER_AC_CMD_TIMER_SET, haier.getCommand());
haier.setCommand(HAIER_AC_CMD_ON);
EXPECT_EQ(6 * 60, haier.getOnTimer()); // 6am
EXPECT_GT(0, haier.getOffTimer());
EXPECT_EQ(HAIER_AC_CMD_ON, haier.getCommand());
haier.cancelTimers();
EXPECT_GT(0, haier.getOnTimer());
EXPECT_GT(0, haier.getOffTimer());
EXPECT_EQ(HAIER_AC_CMD_TIMER_CANCEL, haier.getCommand());
// Off Timer.
haier.setOffTimer(18 * 60 + 30); // 6:30pm
EXPECT_GT(0, haier.getOnTimer());
EXPECT_EQ(18 * 60 + 30, haier.getOffTimer()); // 6:30pm
EXPECT_EQ(HAIER_AC_CMD_TIMER_SET, haier.getCommand());
haier.setCommand(HAIER_AC_CMD_ON);
EXPECT_GT(0, haier.getOnTimer());
EXPECT_EQ(18 * 60 + 30, haier.getOffTimer()); // 6:30pm
EXPECT_EQ(HAIER_AC_CMD_ON, haier.getCommand());
haier.cancelTimers();
EXPECT_GT(0, haier.getOnTimer());
EXPECT_GT(0, haier.getOffTimer());
EXPECT_EQ(HAIER_AC_CMD_TIMER_CANCEL, haier.getCommand());
// Both Timers.
haier.setOnTimer(6 * 60); // 6am
EXPECT_EQ(HAIER_AC_CMD_TIMER_SET, haier.getCommand());
haier.setOffTimer(18 * 60 + 30); // 6:30pm
EXPECT_EQ(HAIER_AC_CMD_TIMER_SET, haier.getCommand());
EXPECT_EQ(6 * 60, haier.getOnTimer()); // 6am
EXPECT_EQ(18 * 60 + 30, haier.getOffTimer()); // 6:30pm
haier.cancelTimers();
EXPECT_GT(0, haier.getOnTimer());
EXPECT_GT(0, haier.getOffTimer());
EXPECT_EQ(HAIER_AC_CMD_TIMER_CANCEL, haier.getCommand());
}
TEST(ElapsedTime, resetSetsTime) {
openlib::ElapsedTime time;
time.reset();
EXPECT_GT(time.startTime(), 0.0);
}
DECLARE_TEST(error, output) {
#if BUILD_ENABLE_LOG
error_callback_fn callback_error = error_callback();
log_callback_fn callback_log = log_callback();
string_const_t shortmsg = string_const(STRING_CONST("Short message with prefix"));
string_const_t longmsg = string_const(STRING_CONST("Longer message which should be output without a prefix"));
error_set_callback(ignore_error_handler);
log_set_callback(log_verify_callback);
log_enable_stdout(false);
log_warn(HASH_TEST, WARNING_SUSPICIOUS, STRING_ARGS(shortmsg));
log_enable_stdout(true);
EXPECT_EQ(_last_log_context, HASH_TEST);
EXPECT_EQ(_last_log_severity, ERRORLEVEL_WARNING);
EXPECT_GE(_last_log_length, shortmsg.length);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("WARNING [suspicious]"), 0), STRING_NPOS);
_last_log_context = 0;
_last_log_severity = ERRORLEVEL_NONE;
_last_log_msg = nullptr;
_last_log_length = 0;
log_enable_stdout(false);
log_warn(HASH_TEST, (warning_t)0x1000, STRING_ARGS(shortmsg));
log_enable_stdout(true);
EXPECT_EQ(_last_log_context, HASH_TEST);
EXPECT_EQ(_last_log_severity, ERRORLEVEL_WARNING);
EXPECT_GE(_last_log_length, shortmsg.length);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("WARNING [4096]"), 0), STRING_NPOS);
_last_log_context = 0;
_last_log_severity = ERRORLEVEL_NONE;
_last_log_msg = nullptr;
_last_log_length = 0;
log_enable_prefix(false);
log_enable_stdout(false);
log_warn(HASH_TEST, WARNING_SYSTEM_CALL_FAIL, STRING_ARGS(longmsg));
log_enable_stdout(true);
log_enable_prefix(true);
EXPECT_EQ(_last_log_context, HASH_TEST);
EXPECT_EQ(_last_log_severity, ERRORLEVEL_WARNING);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), STRING_NPOS);
EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), 0);
_last_log_context = 0;
_last_log_severity = ERRORLEVEL_NONE;
_last_log_msg = nullptr;
_last_log_length = 0;
log_enable_stdout(false);
log_error(HASH_TEST, ERROR_DEPRECATED, STRING_ARGS(shortmsg));
log_enable_stdout(true);
EXPECT_EQ(_last_log_context, HASH_TEST);
EXPECT_EQ(_last_log_severity, ERRORLEVEL_ERROR);
EXPECT_GE(_last_log_length, shortmsg.length);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("ERROR [deprecated]"), 0), STRING_NPOS);
_last_log_context = 0;
_last_log_severity = ERRORLEVEL_NONE;
_last_log_msg = nullptr;
_last_log_length = 0;
log_enable_stdout(false);
log_error(HASH_TEST, (error_t)0x1000, STRING_ARGS(shortmsg));
log_enable_stdout(true);
EXPECT_EQ(_last_log_context, HASH_TEST);
EXPECT_EQ(_last_log_severity, ERRORLEVEL_ERROR);
EXPECT_GE(_last_log_length, shortmsg.length);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("ERROR [4096]"), 0), STRING_NPOS);
_last_log_context = 0;
_last_log_severity = ERRORLEVEL_NONE;
_last_log_msg = nullptr;
_last_log_length = 0;
log_enable_prefix(false);
log_enable_stdout(false);
log_error(HASH_TEST, ERROR_INVALID_VALUE, STRING_ARGS(longmsg));
log_enable_stdout(true);
log_enable_prefix(true);
EXPECT_EQ(_last_log_context, HASH_TEST);
EXPECT_EQ(_last_log_severity, ERRORLEVEL_ERROR);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), STRING_NPOS);
EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), 0);
_last_log_context = 0;
_last_log_severity = ERRORLEVEL_NONE;
_last_log_msg = nullptr;
_last_log_length = 0;
log_enable_stdout(false);
log_panic(HASH_TEST, ERROR_DEPRECATED, STRING_ARGS(shortmsg));
log_enable_stdout(true);
EXPECT_EQ(_last_log_context, HASH_TEST);
EXPECT_EQ(_last_log_severity, ERRORLEVEL_PANIC);
EXPECT_GE(_last_log_length, shortmsg.length);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("PANIC [deprecated]"), 0), STRING_NPOS);
_last_log_context = 0;
_last_log_severity = ERRORLEVEL_NONE;
_last_log_msg = nullptr;
_last_log_length = 0;
log_enable_stdout(false);
log_panic(HASH_TEST, (error_t)0x1000, STRING_ARGS(shortmsg));
log_enable_stdout(true);
EXPECT_EQ(_last_log_context, HASH_TEST);
EXPECT_EQ(_last_log_severity, ERRORLEVEL_PANIC);
EXPECT_GE(_last_log_length, shortmsg.length);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("PANIC [4096]"), 0), STRING_NPOS);
_last_log_context = 0;
_last_log_severity = ERRORLEVEL_NONE;
_last_log_msg = nullptr;
_last_log_length = 0;
log_enable_prefix(false);
log_enable_stdout(false);
log_panic(HASH_TEST, ERROR_INVALID_VALUE, STRING_ARGS(longmsg));
log_enable_stdout(true);
log_enable_prefix(true);
EXPECT_EQ(_last_log_context, HASH_TEST);
EXPECT_EQ(_last_log_severity, ERRORLEVEL_PANIC);
EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), STRING_NPOS);
EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), 0);
error_context_push(STRING_CONST("one"), STRING_CONST("dataone"));
error_context_push(STRING_CONST("two"), STRING_CONST("datatwo"));
error_context_push(STRING_CONST("three"), STRING_CONST("datathree"));
_last_log_context = 0;
_last_log_severity = ERRORLEVEL_NONE;
_last_log_msg = nullptr;
_last_log_length = 0;
log_enable_stdout(false);
log_error_context(HASH_TEST, ERRORLEVEL_INFO);
log_enable_stdout(true);
error_context_pop();
error_context_pop();
error_context_pop();
EXPECT_SIZEEQ(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("When one: dataone"), 0), STRING_NPOS);
EXPECT_SIZEEQ(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("When two: datatwo"), 0), STRING_NPOS);
EXPECT_SIZENE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("When three: datathree"), 0), STRING_NPOS);
log_set_callback(callback_log);
error_set_callback(callback_error);
#endif
return 0;
}
TEST(CalculateInstalledMemoryTest, BasicCheck) {
std::uint64_t installed_memory_in_bytes;
EXPECT_EQ(true, calculateTotalMemoryInBytes(&installed_memory_in_bytes));
EXPECT_GT(installed_memory_in_bytes, 0u);
}
TEST(MovesTest, Score)
{
Board board;
Pieces pieces;
Position position;
MoveList list;
Moves moves(board, pieces, position, list);
Moves::init_mvv_lva_scores();
for (const PieceType& v : PIECE_TYPES) {
for (const PieceType& a : PIECE_TYPES) {
Square to = E5;
Square from;
switch (a) {
case KNIGHT:
from = D3;
break;
default:
from = D4;
break;
}
board[from] = Piece(WHITE, a);
board[to] = Piece(BLACK, v);
Move capture(from, to, CAPTURE);
Score score = moves.mvv_lva_score(capture);
EXPECT_GT(BEST_SCORE, score);
EXPECT_LT(KILLERS_SCORE, score);
for (const PieceType& v2 : PIECE_TYPES) {
for (const PieceType& a2 : PIECE_TYPES) {
switch (a2) {
case KNIGHT:
from = D3;
break;
default:
from = D4;
break;
}
board[from] = Piece(WHITE, a2);
board[to] = Piece(BLACK, v2);
Move capture2(from, to, CAPTURE);
Score score2 = moves.mvv_lva_score(capture2);
if (v > v2) {
EXPECT_GT(score, score2);
} else if (v < v2) {
EXPECT_LT(score, score2);
} else {
if (a > a2) {
EXPECT_LT(score, score2);
} else if (a < a2) {
EXPECT_GT(score, score2);
} else {
EXPECT_EQ(score, score2);
}
}
}
}
}
}
}
TEST(Stats, ByHourSimpleStatsUpdater)
{
// Seed random() for use in simulator; --gtest_shuffle will force it to change.
srandom((unsigned) ::testing::UnitTest::GetInstance()->random_seed());
static_assert(2 == BHSSU::su.maxSamplesPerHour, "constant must propagate correctly");
const uint8_t msph = BHSSU::su.maxSamplesPerHour;
ASSERT_EQ(2, msph);
// Reset static state to make tests re-runnable.
// BHSSU::su.sampleStats(true, 0);
BHSSU::ms.zapStats();
BHSSU::occupancy.reset();
BHSSU::ambLight.set(0, 0, false);
BHSSU::tempC16.set(OTV0P2BASE::TemperatureC16Mock::DEFAULT_INVALID_TEMP);
BHSSU::rh.set(0, false);
const uint8_t unset = OTV0P2BASE::NVByHourByteStatsBase::UNSET_BYTE;
// Set (arbitrary) initial time.
uint8_t hourNow = ((unsigned) random()) % 24;
BHSSU::ms._setHour(hourNow);
// Verify that before first full update stats values unset.
EXPECT_EQ(unset, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, hourNow));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, hourNow));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, hourNow));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, hourNow));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_NEXT_HOUR));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_NEXT_HOUR));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_TEMP_BY_HOUR, hourNow));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_TEMP_BY_HOUR_SMOOTHED, hourNow));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_RHPC_BY_HOUR, hourNow));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_RHPC_BY_HOUR_SMOOTHED, hourNow));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_OCCPC_BY_HOUR, hourNow));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_OCCPC_BY_HOUR_SMOOTHED, hourNow));
// Set initial sensor values.
const uint8_t al0 = 254;
BHSSU::ambLight.set(al0);
const int16_t t0 = 18 << 4;
const uint8_t t0c = OTV0P2BASE::compressTempC16(t0);
ASSERT_NEAR(t0, OTV0P2BASE::expandTempC16(t0c), 1);
BHSSU::tempC16.set(t0);
ASSERT_EQ(18<<4, BHSSU::tempC16.get());
const uint8_t rh0 = ((unsigned) random()) % 101;
BHSSU::rh.set(rh0);
BHSSU::su.sampleStats(true, hourNow);
const uint8_t o0 = 0;
ASSERT_EQ(o0, BHSSU::occupancy.get());
// Verify that after first full update stats values set to specified values.
EXPECT_EQ(al0, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, hourNow));
EXPECT_EQ(al0, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, hourNow));
EXPECT_EQ(al0, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, hourNow));
EXPECT_EQ(al0, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, hourNow));
EXPECT_EQ(al0, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR));
EXPECT_EQ(al0, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_NEXT_HOUR));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_NEXT_HOUR));
EXPECT_EQ(t0c, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_TEMP_BY_HOUR, hourNow));
EXPECT_EQ(t0c, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_TEMP_BY_HOUR_SMOOTHED, hourNow));
EXPECT_EQ(rh0, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_RHPC_BY_HOUR, hourNow));
EXPECT_EQ(rh0, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_RHPC_BY_HOUR_SMOOTHED, hourNow));
EXPECT_EQ(o0, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_OCCPC_BY_HOUR, hourNow));
EXPECT_EQ(o0, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_OCCPC_BY_HOUR_SMOOTHED, hourNow));
// Nominally roll round a day and update the same slot for new sensor values.
const uint8_t al1 = 0;
BHSSU::ambLight.set(al1);
const uint8_t o1 = 100;
BHSSU::occupancy.markAsOccupied();
ASSERT_EQ(o1, BHSSU::occupancy.get());
const uint8_t rh1 = ((unsigned) random()) % 101;
BHSSU::rh.set(rh1);
// Compute expected (approximate) smoothed values.
const uint8_t sm_al1 = OTV0P2BASE::NVByHourByteStatsBase::smoothStatsValue(al0, al1);
EXPECT_LT(al1, sm_al1);
EXPECT_GT(al0, sm_al1);
const uint8_t sm_o1 = OTV0P2BASE::NVByHourByteStatsBase::smoothStatsValue(o0, o1);
const uint8_t sm_rh1 = OTV0P2BASE::NVByHourByteStatsBase::smoothStatsValue(rh0, rh1);
// Take single/final/full sample.
BHSSU::su.sampleStats(true, hourNow);
EXPECT_EQ(al1, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, hourNow));
EXPECT_NEAR(sm_al1, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, hourNow), 1);
EXPECT_EQ(al1, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, hourNow));
EXPECT_NEAR(sm_al1, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, hourNow), 1);
EXPECT_EQ(al1, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR));
EXPECT_NEAR(sm_al1, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR), 1);
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_NEXT_HOUR));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_NEXT_HOUR));
EXPECT_EQ(t0c, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_TEMP_BY_HOUR, hourNow));
EXPECT_EQ(t0c, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_TEMP_BY_HOUR_SMOOTHED, hourNow));
EXPECT_EQ(rh1, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_RHPC_BY_HOUR, hourNow));
EXPECT_NEAR(sm_rh1, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_RHPC_BY_HOUR_SMOOTHED, hourNow), 1);
EXPECT_EQ(o1, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_OCCPC_BY_HOUR, hourNow));
EXPECT_NEAR(sm_o1, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_OCCPC_BY_HOUR_SMOOTHED, hourNow), 1);
// Move to next hour.
const uint8_t nextHour = (hourNow + 1) % 24;
BHSSU::ms._setHour(nextHour);
// Take a couple of samples for this hour.
BHSSU::ambLight.set(al0);
BHSSU::rh.set(rh0);
BHSSU::su.sampleStats(false, nextHour);
BHSSU::ambLight.set(al1);
BHSSU::rh.set(rh1);
BHSSU::su.sampleStats(true, nextHour);
// Expect to see the mean of the first and second sample as the stored value.
// Note that this exercises sensor data that is handled differently (eg full-range AmbLight vs RH%).
const uint8_t al01 = (al0 + al1 + 1) / 2;
const uint8_t rh01 = (rh0 + rh1 + 1) / 2;
EXPECT_EQ(al01, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, nextHour));
EXPECT_EQ(al01, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, nextHour));
EXPECT_EQ(al01, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, nextHour));
EXPECT_EQ(al01, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, nextHour));
EXPECT_EQ(al01, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR));
EXPECT_EQ(al01, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_NEXT_HOUR));
EXPECT_EQ(unset, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_NEXT_HOUR));
EXPECT_EQ(t0c, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_TEMP_BY_HOUR, nextHour));
EXPECT_EQ(t0c, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_TEMP_BY_HOUR_SMOOTHED, nextHour));
EXPECT_EQ(rh01, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_RHPC_BY_HOUR, nextHour));
EXPECT_EQ(rh01, BHSSU::ms.getByHourStatSimple(BHSSU::ms.STATS_SET_RHPC_BY_HOUR_SMOOTHED, nextHour));
EXPECT_EQ(rh01, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_RHPC_BY_HOUR, nextHour));
EXPECT_EQ(rh01, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_RHPC_BY_HOUR_SMOOTHED, nextHour));
EXPECT_EQ(rh01, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_RHPC_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR));
EXPECT_EQ(rh01, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_RHPC_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR));
// Nominally roll round a day and check the first slot's values via the RTC view.
BHSSU::ms._setHour(hourNow);
EXPECT_EQ(al1, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR));
EXPECT_NEAR(sm_al1, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_CURRENT_HOUR), 2);
EXPECT_EQ(al01, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR, BHSSU::ms.SPECIAL_HOUR_NEXT_HOUR));
EXPECT_EQ(al01, BHSSU::ms.getByHourStatRTC(BHSSU::ms.STATS_SET_AMBLIGHT_BY_HOUR_SMOOTHED, BHSSU::ms.SPECIAL_HOUR_NEXT_HOUR));
}
TEST(HeuristicTest, GreaterThan)
{
auto gb = GameBoard{" /OX / "};
// Best moves are {0,0}, {2,0}, {1,0}, and {2,1} in that order
EXPECT_GT(gb.getHeuristic(Move{0,0}), gb.getHeuristic(Move{2,0}));
}
TEST(ExpressionLiteralDefinitionTest, Construct) {
ExpressionLiteralDefinition definition;
EXPECT_GT(definition.getPattern().size(), 2);
}
TEST(logcat, blocking_clear) {
FILE *fp;
unsigned long long v = 0xDEADBEEFA55C0000ULL;
pid_t pid = getpid();
v += pid & 0xFFFF;
// This test is racey; an event occurs between clear and dump.
// We accept that we will get a false positive, but never a false negative.
ASSERT_TRUE(NULL != (fp = popen(
"( trap exit HUP QUIT INT PIPE KILL ; sleep 6; echo DONE )&"
" logcat -b events -c 2>&1 ;"
" logcat -b events -g 2>&1 ;"
" logcat -v brief -b events 2>&1",
"r")));
char buffer[BIG_BUFFER];
int count = 0;
int minus_g = 0;
int signals = 0;
signal(SIGALRM, caught_blocking_clear);
alarm(2);
while (fgets(buffer, sizeof(buffer), fp)) {
if (!strncmp(buffer, "clearLog: ", 10)) {
fprintf(stderr, "WARNING: Test lacks permission to run :-(\n");
count = signals = 1;
break;
}
if (!strncmp(buffer, "DONE", 4)) {
break;
}
int size, consumed, max, payload;
char size_mult[3], consumed_mult[3];
size = consumed = max = payload = 0;
if (6 == sscanf(buffer, "events: ring buffer is %d%2s (%d%2s consumed),"
" max entry is %db, max payload is %db",
&size, size_mult, &consumed, consumed_mult,
&max, &payload)) {
long full_size = size, full_consumed = consumed;
switch(size_mult[0]) {
case 'G':
full_size *= 1024;
/* FALLTHRU */
case 'M':
full_size *= 1024;
/* FALLTHRU */
case 'K':
full_size *= 1024;
/* FALLTHRU */
case 'b':
break;
}
switch(consumed_mult[0]) {
case 'G':
full_consumed *= 1024;
/* FALLTHRU */
case 'M':
full_consumed *= 1024;
/* FALLTHRU */
case 'K':
full_consumed *= 1024;
/* FALLTHRU */
case 'b':
break;
}
EXPECT_GT(full_size, full_consumed);
EXPECT_GT(full_size, max);
EXPECT_GT(max, payload);
EXPECT_GT(max, full_consumed);
++minus_g;
continue;
}
++count;
int p;
unsigned long long l;
if ((2 != sscanf(buffer, "I/[0] ( %u): %lld", &p, &l))
|| (p != pid)) {
continue;
}
if (l == v) {
if (count > 1) {
fprintf(stderr, "WARNING: Possible false positive\n");
}
++signals;
break;
}
}
alarm(0);
signal(SIGALRM, SIG_DFL);
// Generate SIGPIPE
fclose(fp);
caught_blocking_clear(0);
pclose(fp);
EXPECT_LE(1, count);
EXPECT_EQ(1, minus_g);
EXPECT_EQ(1, signals);
}
TEST(Fuzzy, setInputAndFuzzifyAndDefuzzify01){
Fuzzy* fuzzy = new Fuzzy();
// FuzzyInput
FuzzyInput* temperature = new FuzzyInput(1);
FuzzySet* low = new FuzzySet(0, 10, 10, 20);
temperature->addFuzzySet(low);
FuzzySet* mean = new FuzzySet(10, 20, 30, 40);
temperature->addFuzzySet(mean);
FuzzySet* high = new FuzzySet(30, 40, 40, 50);
temperature->addFuzzySet(high);
fuzzy->addFuzzyInput(temperature);
// FuzzyOutput
FuzzyOutput* climate = new FuzzyOutput(1);
FuzzySet* cold = new FuzzySet(0, 10, 10, 20);
climate->addFuzzySet(cold);
FuzzySet* good = new FuzzySet(10, 20, 30, 40);
climate->addFuzzySet(good);
FuzzySet* hot = new FuzzySet(30, 40, 40, 50);
climate->addFuzzySet(hot);
fuzzy->addFuzzyOutput(climate);
// Building FuzzyRule
FuzzyRuleAntecedent* ifTemperatureLow = new FuzzyRuleAntecedent();
ifTemperatureLow->joinSingle(low);
FuzzyRuleConsequent* thenClimateCold = new FuzzyRuleConsequent();
thenClimateCold->addOutput(cold);
FuzzyRule* fuzzyRule1 = new FuzzyRule(1, ifTemperatureLow, thenClimateCold);
fuzzy->addFuzzyRule(fuzzyRule1);
// Building FuzzyRule
FuzzyRuleAntecedent* ifTemperatureMean = new FuzzyRuleAntecedent();
ifTemperatureMean->joinSingle(mean);
FuzzyRuleConsequent* thenClimateGood = new FuzzyRuleConsequent();
thenClimateGood->addOutput(good);
FuzzyRule* fuzzyRule2 = new FuzzyRule(2, ifTemperatureMean, thenClimateGood);
fuzzy->addFuzzyRule(fuzzyRule2);
// Building FuzzyRule
FuzzyRuleAntecedent* ifTemperatureHigh = new FuzzyRuleAntecedent();
ifTemperatureHigh->joinSingle(low);
FuzzyRuleConsequent* thenClimateHot = new FuzzyRuleConsequent();
thenClimateHot->addOutput(cold);
FuzzyRule* fuzzyRule3 = new FuzzyRule(3, ifTemperatureHigh, thenClimateHot);
fuzzy->addFuzzyRule(fuzzyRule3);
bool result1 = fuzzy->setInput(1, 15);
bool result2 = fuzzy->fuzzify();
float output = fuzzy->defuzzify(1);
EXPECT_TRUE(result1);
EXPECT_TRUE(result2);
EXPECT_GT(output, 0.0);
}
void mustBeLessThan(T expected) {
EXPECT_LT(actual, expected); // operator<
EXPECT_GT(expected, actual); // operator<
EXPECT_NE(actual, expected); // operator!=
EXPECT_NE(expected, actual); // operator!=
}
TEST(Fuzzy, setInputAndFuzzifyAndDefuzzify03){
Fuzzy* fuzzy = new Fuzzy();
// FuzzyInput
FuzzyInput* temperature = new FuzzyInput(1);
FuzzySet* low = new FuzzySet(-30, -20, -20, -10);
temperature->addFuzzySet(low);
FuzzySet* mean = new FuzzySet(-20, -10, 10, 20);
temperature->addFuzzySet(mean);
FuzzySet* high = new FuzzySet(10, 20, 20, 30);
temperature->addFuzzySet(high);
fuzzy->addFuzzyInput(temperature);
// FuzzyInput
FuzzyInput* pressure = new FuzzyInput(2);
FuzzySet* small = new FuzzySet(-30, -20, -20, -10);
pressure->addFuzzySet(small);
FuzzySet* normal = new FuzzySet(-20, -10, 10, 20);
pressure->addFuzzySet(normal);
FuzzySet* big = new FuzzySet(10, 20, 20, 30);
pressure->addFuzzySet(big);
fuzzy->addFuzzyInput(pressure);
// FuzzyOutput
FuzzyOutput* risk = new FuzzyOutput(1);
FuzzySet* minimum = new FuzzySet(-30, -20, -20, -10);
risk->addFuzzySet(minimum);
FuzzySet* average = new FuzzySet(-20, -10, 10, 20);
risk->addFuzzySet(average);
FuzzySet* maximum = new FuzzySet(10, 20, 20, 30);
risk->addFuzzySet(maximum);
fuzzy->addFuzzyOutput(risk);
// Building FuzzyRule
FuzzyRuleAntecedent* ifTemperatureLowAndPressureSmall = new FuzzyRuleAntecedent();
ifTemperatureLowAndPressureSmall->joinWithAND(low, small);
FuzzyRuleConsequent* thenRiskMinimum = new FuzzyRuleConsequent();
thenRiskMinimum->addOutput(minimum);
FuzzyRule* fuzzyRule1 = new FuzzyRule(1, ifTemperatureLowAndPressureSmall, thenRiskMinimum);
fuzzy->addFuzzyRule(fuzzyRule1);
// Building FuzzyRule
FuzzyRuleAntecedent* ifTemperatureMeanAndPressureNormal = new FuzzyRuleAntecedent();
ifTemperatureMeanAndPressureNormal->joinWithAND(mean, normal);
FuzzyRuleConsequent* theRiskAverage = new FuzzyRuleConsequent();
theRiskAverage->addOutput(average);
FuzzyRule* fuzzyRule2 = new FuzzyRule(2, ifTemperatureMeanAndPressureNormal, theRiskAverage);
fuzzy->addFuzzyRule(fuzzyRule2);
// Building FuzzyRule
FuzzyRuleAntecedent* ifTemperatureHighAndPressureBig = new FuzzyRuleAntecedent();
ifTemperatureHighAndPressureBig->joinWithAND(high, big);
FuzzyRuleConsequent* thenRiskMaximum = new FuzzyRuleConsequent();
thenRiskMaximum->addOutput(maximum);
FuzzyRule* fuzzyRule3 = new FuzzyRule(3, ifTemperatureHighAndPressureBig, thenRiskMaximum);
fuzzy->addFuzzyRule(fuzzyRule3);
fuzzy->setInput(1, -25);
fuzzy->setInput(2, -15);
fuzzy->fuzzify();
bool fuzzyRule1IsFired = fuzzy->isFiredRule(1);
float output = fuzzy->defuzzify(1);
EXPECT_GT(0.0, output);
EXPECT_TRUE(fuzzyRule1IsFired);
}
TEST(unistd, _POSIX_macros_smoke) {
// Make a tight verification of _POSIX_* / _POSIX2_* / _XOPEN_* macros, to prevent change by mistake.
// Verify according to POSIX.1-2008.
EXPECT_EQ(200809L, _POSIX_VERSION);
EXPECT_EQ(_POSIX_VERSION, _POSIX_ADVISORY_INFO);
EXPECT_GT(_POSIX_AIO_LISTIO_MAX, 0);
EXPECT_GT(_POSIX_AIO_MAX, 0);
EXPECT_GT(_POSIX_ARG_MAX, 0);
EXPECT_GT(_POSIX_CHILD_MAX, 0);
EXPECT_NE(_POSIX_CHOWN_RESTRICTED, -1);
EXPECT_EQ(_POSIX_VERSION, _POSIX_CLOCK_SELECTION);
EXPECT_EQ(0, _POSIX_CPUTIME); // Use sysconf to detect support at runtime.
EXPECT_GT(_POSIX_DELAYTIMER_MAX, 0);
EXPECT_EQ(_POSIX_VERSION, _POSIX_FSYNC);
EXPECT_GT(_POSIX_HOST_NAME_MAX, 0);
EXPECT_EQ(_POSIX_VERSION, _POSIX_IPV6);
EXPECT_GT(_POSIX_JOB_CONTROL, 0);
EXPECT_GT(_POSIX_LINK_MAX, 0);
EXPECT_GT(_POSIX_LOGIN_NAME_MAX, 0);
EXPECT_EQ(_POSIX_VERSION, _POSIX_MAPPED_FILES);
EXPECT_GT(_POSIX_MAX_CANON, 0);
EXPECT_GT(_POSIX_MAX_INPUT, 0);
EXPECT_EQ(_POSIX_VERSION, _POSIX_MEMLOCK);
EXPECT_EQ(_POSIX_VERSION, _POSIX_MEMLOCK_RANGE);
EXPECT_EQ(_POSIX_VERSION, _POSIX_MEMORY_PROTECTION);
EXPECT_EQ(0, _POSIX_MONOTONIC_CLOCK);
EXPECT_GT(_POSIX_MQ_OPEN_MAX, 0);
EXPECT_GT(_POSIX_MQ_PRIO_MAX, 0);
EXPECT_GT(_POSIX_NAME_MAX, 0);
EXPECT_GT(_POSIX_NGROUPS_MAX, 0);
EXPECT_GT(_POSIX_NO_TRUNC, 0);
EXPECT_GT(_POSIX_OPEN_MAX, 0);
EXPECT_GT(_POSIX_PATH_MAX, 0);
EXPECT_GT(_POSIX_PIPE_BUF, 0);
EXPECT_EQ(_POSIX_VERSION, _POSIX_PRIORITY_SCHEDULING);
EXPECT_EQ(_POSIX_VERSION, _POSIX_RAW_SOCKETS);
EXPECT_EQ(_POSIX_VERSION, _POSIX_READER_WRITER_LOCKS);
EXPECT_EQ(_POSIX_VERSION, _POSIX_REALTIME_SIGNALS);
EXPECT_GT(_POSIX_REGEXP, 0);
EXPECT_GT(_POSIX_RE_DUP_MAX, 0);
EXPECT_GT(_POSIX_SAVED_IDS, 0);
EXPECT_EQ(_POSIX_VERSION, _POSIX_SEMAPHORES);
EXPECT_GT(_POSIX_SEM_NSEMS_MAX, 0);
EXPECT_GT(_POSIX_SEM_VALUE_MAX, 0);
EXPECT_GT(_POSIX_SHELL, 0);
EXPECT_GT(_POSIX_SIGQUEUE_MAX, 0);
EXPECT_EQ(-1, _POSIX_SPORADIC_SERVER);
EXPECT_GT(_POSIX_SSIZE_MAX, 0);
EXPECT_GT(_POSIX_STREAM_MAX, 0);
EXPECT_GT(_POSIX_SYMLINK_MAX, 0);
EXPECT_GT(_POSIX_SYMLOOP_MAX, 0);
EXPECT_EQ(_POSIX_VERSION, _POSIX_SYNCHRONIZED_IO);
EXPECT_EQ(_POSIX_VERSION, _POSIX_THREADS);
EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_ATTR_STACKADDR);
EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_ATTR_STACKSIZE);
EXPECT_EQ(0, _POSIX_THREAD_CPUTIME); // Use sysconf to detect support at runtime.
EXPECT_GT(_POSIX_THREAD_DESTRUCTOR_ITERATIONS, 0);
EXPECT_EQ(_POSIX_THREAD_KEYS_MAX, 128);
EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_PRIORITY_SCHEDULING);
EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_PRIO_INHERIT);
EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_PRIO_PROTECT);
EXPECT_EQ(-1, _POSIX_THREAD_ROBUST_PRIO_PROTECT);
EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_SAFE_FUNCTIONS);
EXPECT_EQ(-1, _POSIX_THREAD_SPORADIC_SERVER);
EXPECT_GT(_POSIX_THREAD_THREADS_MAX, 0);
EXPECT_EQ(_POSIX_VERSION, _POSIX_TIMEOUTS);
EXPECT_EQ(_POSIX_VERSION, _POSIX_TIMERS);
EXPECT_GT(_POSIX_TIMER_MAX, 0);
EXPECT_EQ(-1, _POSIX_TRACE);
EXPECT_EQ(-1, _POSIX_TRACE_EVENT_FILTER);
EXPECT_EQ(-1, _POSIX_TRACE_INHERIT);
EXPECT_EQ(-1, _POSIX_TRACE_LOG);
EXPECT_GT(_POSIX_TTY_NAME_MAX, 0);
EXPECT_EQ(-1, _POSIX_TYPED_MEMORY_OBJECTS);
EXPECT_GT(_POSIX_TZNAME_MAX, 0);
EXPECT_NE(-1, _POSIX_VDISABLE);
EXPECT_GT(_POSIX2_BC_BASE_MAX, 0);
EXPECT_GT(_POSIX2_BC_DIM_MAX, 0);
EXPECT_GT(_POSIX2_BC_SCALE_MAX, 0);
EXPECT_GT(_POSIX2_BC_STRING_MAX, 0);
EXPECT_GT(_POSIX2_CHARCLASS_NAME_MAX, 0);
EXPECT_GT(_POSIX2_COLL_WEIGHTS_MAX, 0);
EXPECT_EQ(_POSIX_VERSION, _POSIX2_C_BIND);
EXPECT_GT(_POSIX2_EXPR_NEST_MAX, 0);
EXPECT_GT(_POSIX2_LINE_MAX, 0);
EXPECT_GT(_POSIX2_RE_DUP_MAX, 0);
EXPECT_EQ(700, _XOPEN_VERSION);
EXPECT_GT(_XOPEN_IOV_MAX, 0);
EXPECT_GT(_XOPEN_UNIX, 0);
#if defined(__BIONIC__)
// These tests only pass on bionic, as bionic and glibc has different support on these macros.
// Macros like _POSIX_ASYNCHRONOUS_IO are not supported on bionic yet.
EXPECT_EQ(-1, _POSIX_ASYNCHRONOUS_IO);
EXPECT_EQ(-1, _POSIX_BARRIERS);
EXPECT_EQ(-1, _POSIX_MESSAGE_PASSING);
EXPECT_EQ(-1, _POSIX_PRIORITIZED_IO);
EXPECT_EQ(-1, _POSIX_SHARED_MEMORY_OBJECTS);
EXPECT_EQ(-1, _POSIX_SPAWN);
EXPECT_EQ(-1, _POSIX_SPIN_LOCKS);
EXPECT_EQ(-1, _POSIX_THREAD_PROCESS_SHARED);
EXPECT_EQ(-1, _POSIX_THREAD_ROBUST_PRIO_INHERIT);
EXPECT_EQ(-1, _POSIX2_VERSION);
EXPECT_EQ(-1, _POSIX2_CHAR_TERM);
EXPECT_EQ(-1, _POSIX2_C_DEV);
EXPECT_EQ(-1, _POSIX2_LOCALEDEF);
EXPECT_EQ(-1, _POSIX2_SW_DEV);
EXPECT_EQ(-1, _POSIX2_UPE);
EXPECT_EQ(-1, _XOPEN_ENH_I18N);
EXPECT_EQ(-1, _XOPEN_CRYPT);
EXPECT_EQ(-1, _XOPEN_LEGACY);
EXPECT_EQ(-1, _XOPEN_REALTIME);
EXPECT_EQ(-1, _XOPEN_REALTIME_THREADS);
EXPECT_EQ(-1, _XOPEN_SHM);
#endif // defined(__BIONIC__)
}
TEST_F(PropertiesTest, SetString) {
// Null key -> unsuccessful set
{
// Null key -> fails
EXPECT_GT(0, property_set(/*key*/NULL, PROPERTY_TEST_VALUE_DEFAULT));
}
// Null value -> returns default value
{
// Null value -> OK , and it clears the value
EXPECT_OK(property_set(PROPERTY_TEST_KEY, /*value*/NULL));
ResetValue();
// Since the value is null, default value will be returned
int len = property_get(PROPERTY_TEST_KEY, mValue, PROPERTY_TEST_VALUE_DEFAULT);
EXPECT_EQ(strlen(PROPERTY_TEST_VALUE_DEFAULT), len);
EXPECT_STREQ(PROPERTY_TEST_VALUE_DEFAULT, mValue);
}
// Trivial case => get returns what was set
{
int len = SetAndGetProperty("hello_world");
EXPECT_EQ(strlen("hello_world"), len) << "hello_world key";
EXPECT_STREQ("hello_world", mValue);
ResetValue();
}
// Set to empty string => get returns default always
{
const char* EMPTY_STRING_DEFAULT = "EMPTY_STRING";
int len = SetAndGetProperty("", EMPTY_STRING_DEFAULT);
EXPECT_EQ(strlen(EMPTY_STRING_DEFAULT), len) << "empty key";
EXPECT_STREQ(EMPTY_STRING_DEFAULT, mValue);
ResetValue();
}
// Set to max length => get returns what was set
{
std::string maxLengthString = std::string(PROPERTY_VALUE_MAX-1, 'a');
int len = SetAndGetProperty(maxLengthString.c_str());
EXPECT_EQ(PROPERTY_VALUE_MAX-1, len) << "max length key";
EXPECT_STREQ(maxLengthString.c_str(), mValue);
ResetValue();
}
// Set to max length + 1 => set fails
{
const char* VALID_TEST_VALUE = "VALID_VALUE";
ASSERT_OK(property_set(PROPERTY_TEST_KEY, VALID_TEST_VALUE));
std::string oneLongerString = std::string(PROPERTY_VALUE_MAX, 'a');
// Expect that the value set fails since it's too long
EXPECT_GT(0, property_set(PROPERTY_TEST_KEY, oneLongerString.c_str()));
int len = property_get(PROPERTY_TEST_KEY, mValue, PROPERTY_TEST_VALUE_DEFAULT);
EXPECT_EQ(strlen(VALID_TEST_VALUE), len) << "set should've failed";
EXPECT_STREQ(VALID_TEST_VALUE, mValue);
ResetValue();
}
}
// Test GetClustCf (Distribution and Closed and Open)
TEST(triad, TestGetClustCfDistCO) {
const int ExpClosedTr = 3; // Expected closed triads
const int ExpOpenTr = 9; // Expected open triads
// Test TUNGraph
PUNGraph GraphTUN = TriadGetTestTUNGraph();
TFltPrV DegToCCfV;
int64 ClosedTr = 0;
int64 OpenTr = 0;
TSnap::GetClustCf(GraphTUN, DegToCCfV, ClosedTr, OpenTr);
TestDegToCCfVector(DegToCCfV);
EXPECT_EQ(ExpClosedTr, ClosedTr);
EXPECT_EQ(ExpOpenTr, OpenTr);
TSnap::GetClustCfAll(GraphTUN, DegToCCfV, ClosedTr, OpenTr);
TestDegToCCfVector(DegToCCfV);
EXPECT_EQ(ExpClosedTr, ClosedTr);
EXPECT_EQ(ExpOpenTr, OpenTr);
// TNGraph should be treated as TUNGraph for calculations
PNGraph GraphTN = TriadGetTestTNGraph();
DegToCCfV.Clr();
ClosedTr = 0;
OpenTr = 0;
TSnap::GetClustCf(GraphTN, DegToCCfV, ClosedTr, OpenTr);
TestDegToCCfVector(DegToCCfV);
EXPECT_EQ(ExpClosedTr, ClosedTr);
EXPECT_EQ(ExpOpenTr, OpenTr);
TSnap::GetClustCfAll(GraphTN, DegToCCfV, ClosedTr, OpenTr);
TestDegToCCfVector(DegToCCfV);
EXPECT_EQ(ExpClosedTr, ClosedTr);
EXPECT_EQ(ExpOpenTr, OpenTr);
// TNEGraph is not treated the same! Be careful with multigraphs
PNEGraph GraphTNE = TriadGetTestTNEGraph();
DegToCCfV.Clr();
ClosedTr = 0;
OpenTr = 0;
TSnap::GetClustCf(GraphTNE, DegToCCfV, ClosedTr, OpenTr);
for (TFltPr *Pair = DegToCCfV.BegI(); Pair < DegToCCfV.EndI(); Pair++) {
double Diff = Pair->Val2 - 5.0/9.0; // Used for case 4
Diff = (Diff < 0) ? -1.0*Diff : Diff; // Used for case 4
switch ((int) Pair->Val1) {
case 2:
EXPECT_EQ(1.0, Pair->Val2);
break;
case 4:
EXPECT_GT(0.00001, Diff); // Due to floats being imprecise
break;
case 7:
EXPECT_EQ(2.0/3.0, Pair->Val2);
break;
case 15:
EXPECT_EQ(0.3, Pair->Val2);
break;
default:
ASSERT_FALSE(true); // Shouldn't have degrees other than listed
break;
}
}
EXPECT_EQ(ExpClosedTr, ClosedTr);
EXPECT_EQ(ExpOpenTr, OpenTr);
TSnap::GetClustCfAll(GraphTNE, DegToCCfV, ClosedTr, OpenTr);
for (TFltPr *Pair = DegToCCfV.BegI(); Pair < DegToCCfV.EndI(); Pair++) {
double Diff = Pair->Val2 - 5.0/9.0; // Used for case 4
Diff = (Diff < 0) ? -1.0*Diff : Diff; // Used for case 4
switch ((int) Pair->Val1) {
case 2:
EXPECT_EQ(1.0, Pair->Val2);
break;
case 4:
EXPECT_GT(0.00001, Diff); // Due to floats being imprecise
break;
case 7:
EXPECT_EQ(2.0/3.0, Pair->Val2);
break;
case 15:
EXPECT_EQ(0.3, Pair->Val2);
break;
default:
ASSERT_FALSE(true); // Shouldn't have degrees other than listed
break;
}
}
EXPECT_EQ(ExpClosedTr, ClosedTr);
EXPECT_EQ(ExpOpenTr, OpenTr);
}
TEST(logcat, get_size) {
FILE *fp;
// NB: crash log only available in user space
ASSERT_TRUE(NULL != (fp = popen(
"logcat -v brief -b radio -b events -b system -b main -g 2>/dev/null",
"r")));
char buffer[5120];
int count = 0;
while (fgets(buffer, sizeof(buffer), fp)) {
int size, consumed, max, payload;
char size_mult[3], consumed_mult[3];
long full_size, full_consumed;
size = consumed = max = payload = 0;
// NB: crash log can be very small, not hit a Kb of consumed space
// doubly lucky we are not including it.
if (6 != sscanf(buffer, "%*s ring buffer is %d%2s (%d%2s consumed),"
" max entry is %db, max payload is %db",
&size, size_mult, &consumed, consumed_mult,
&max, &payload)) {
fprintf(stderr, "WARNING: Parse error: %s", buffer);
continue;
}
full_size = size;
switch(size_mult[0]) {
case 'G':
full_size *= 1024;
/* FALLTHRU */
case 'M':
full_size *= 1024;
/* FALLTHRU */
case 'K':
full_size *= 1024;
/* FALLTHRU */
case 'b':
break;
}
full_consumed = consumed;
switch(consumed_mult[0]) {
case 'G':
full_consumed *= 1024;
/* FALLTHRU */
case 'M':
full_consumed *= 1024;
/* FALLTHRU */
case 'K':
full_consumed *= 1024;
/* FALLTHRU */
case 'b':
break;
}
EXPECT_GT((full_size * 9) / 4, full_consumed);
EXPECT_GT(full_size, max);
EXPECT_GT(max, payload);
if ((((full_size * 9) / 4) >= full_consumed)
&& (full_size > max)
&& (max > payload)) {
++count;
}
}
pclose(fp);
ASSERT_EQ(4, count);
}
TEST_F(Platform, pow) {
double sum = 0;
for (int i = 0; i < kTrialCount * kTrialCount; i++)
sum += pow(10.0, i & 255);
EXPECT_GT(sum, 0.0);
}
TEST(RealWordTest, XORLinear)
{
typedef NeuralNetwork<double, LinearActivationFunction<double >> network;
network nn;
//nn.setActivationfunction(LinearActivationFunction<double>(10));
nn.setEntries(2);
nn.setExits(1);
nn.setLayersCount(2);
nn.setNeurons(1, 2);
nn.init();
std::vector<double> in1(2);
std::vector<double> in2(2);
std::vector<double> in3(2);
std::vector<double> in4(2);
in1[0] = 0;
in1[1] = 0;
in2[0] = 1;
in2[1] = 0;
in3[0] = 0;
in3[1] = 1;
in4[0] = 1;
in4[1] = 1;
std::vector<double> out0(1);
std::vector<double> out1(1);
out0[0] = 0;
out1[0] = 1;
//uczenie
for (int i = 0; i < 1000; ++i)
{
std::vector<double> o(1);
nn.setInput(in1.begin(), in1.end());
o = nn.calcOutput();
nn.learn(out0.begin(), out0.end());
//
// std::cout << "Wynik0: " << o[0] << "\n";
// nn.printWages();
nn.setInput(in2.begin(), in2.end());
o = nn.calcOutput();
nn.learn(out1.begin(), out1.end());
//
// std::cout << "Wynik1: " << o[0] << "\n";
// nn.printWages();
nn.setInput(in3.begin(), in3.end());
o = nn.calcOutput();
nn.learn(out1.begin(), out1.end());
//
// std::cout << "Wynik1: " << o[0] << "\n";
// nn.printWages();
nn.setInput(in4.begin(), in4.end());
o = nn.calcOutput();
nn.learn(out0.begin(), out0.end());
//
// std::cout << "Wynik0: " << o[0] << "\n";
// nn.printWages();
}
//test
std::vector<double> out;
std::vector<double> o(4);
nn.setInput(in1.begin(), in1.end());
out = nn.calcOutput();
o[0] = out[0];
EXPECT_LT(out[0], 0.1);
nn.setInput(in2.begin(), in2.end());
out = nn.calcOutput();
o[1] = out[0];
EXPECT_GT(out[0], 0.9);
nn.setInput(in3.begin(), in3.end());
out = nn.calcOutput();
o[2] = out[0];
EXPECT_GT(out[0], 0.9);
nn.setInput(in4.begin(), in4.end());
out = nn.calcOutput();
o[3] = out[0];
EXPECT_LT(out[0], 0.1);
//std::cout << o[0] << " " << o[1] << " " << o[2] << " " << o[3] << "\n";
}
TEST(OmplPlanning, PathConstrainedSimplePlan)
{
ros::NodeHandle nh;
ros::service::waitForService(PLANNER_SERVICE_NAME);
ros::Publisher pub = nh.advertise<moveit_msgs::DisplayTrajectory>("display_motion_plan", 1);
ros::ServiceClient planning_service_client = nh.serviceClient<moveit_msgs::GetMotionPlan>(PLANNER_SERVICE_NAME);
EXPECT_TRUE(planning_service_client.exists());
EXPECT_TRUE(planning_service_client.isValid());
moveit_msgs::GetMotionPlan::Request mplan_req;
moveit_msgs::GetMotionPlan::Response mplan_res;
planning_scene_monitor::PlanningSceneMonitor psm(ROBOT_DESCRIPTION);
planning_scene::PlanningScene &scene = *psm.getPlanningScene();
EXPECT_TRUE(scene.isConfigured());
mplan_req.motion_plan_request.planner_id = "RRTConnectkConfigDefault";
mplan_req.motion_plan_request.group_name = "right_arm";
mplan_req.motion_plan_request.num_planning_attempts = 1;
mplan_req.motion_plan_request.allowed_planning_time = ros::Duration(15.0);
const std::vector<std::string>& joint_names = scene.getRobotModel()->getJointModelGroup("right_arm")->getJointModelNames();
mplan_req.motion_plan_request.start_state.joint_state.name = joint_names;
mplan_req.motion_plan_request.start_state.joint_state.position.push_back(-1.21044517893021499);
mplan_req.motion_plan_request.start_state.joint_state.position.push_back(0.038959594993384528);
mplan_req.motion_plan_request.start_state.joint_state.position.push_back(-0.81412902362644646);
mplan_req.motion_plan_request.start_state.joint_state.position.push_back(-1.0989597173881371);
mplan_req.motion_plan_request.start_state.joint_state.position.push_back(2.3582101183671629);
mplan_req.motion_plan_request.start_state.joint_state.position.push_back(-1.993988668449755);
mplan_req.motion_plan_request.start_state.joint_state.position.push_back(-2.2779628049776051);
moveit_msgs::PositionConstraint pcm;
pcm.link_name = "r_wrist_roll_link";
pcm.header.frame_id = psm.getPlanningScene()->getPlanningFrame();
pcm.constraint_region.primitive_poses.resize(1);
pcm.constraint_region.primitive_poses[0].position.x = 0.5;
pcm.constraint_region.primitive_poses[0].position.y = 0.0;
pcm.constraint_region.primitive_poses[0].position.z = 0.7;
pcm.constraint_region.primitive_poses[0].orientation.w = 1.0;
pcm.constraint_region.primitives.resize(1);
pcm.constraint_region.primitives[0].type = shape_msgs::SolidPrimitive::BOX;
pcm.constraint_region.primitives[0].dimensions.x = 0.1;
pcm.constraint_region.primitives[0].dimensions.y = 0.1;
pcm.constraint_region.primitives[0].dimensions.z = 0.1;
pcm.weight = 1.0;
mplan_req.motion_plan_request.goal_constraints.resize(1);
mplan_req.motion_plan_request.goal_constraints[0].position_constraints.push_back(pcm);
// add path constraints
moveit_msgs::Constraints &constr = mplan_req.motion_plan_request.path_constraints;
constr.orientation_constraints.resize(1);
moveit_msgs::OrientationConstraint &ocm = constr.orientation_constraints[0];
ocm.link_name = "r_wrist_roll_link";
ocm.header.frame_id = psm.getPlanningScene()->getPlanningFrame();
ocm.orientation.x = 0.0;
ocm.orientation.y = 0.0;
ocm.orientation.z = 0.0;
ocm.orientation.w = 1.0;
ocm.absolute_x_axis_tolerance = 0.15;
ocm.absolute_y_axis_tolerance = 0.15;
ocm.absolute_z_axis_tolerance = M_PI;
ocm.weight = 1.0;
std::cout << mplan_req.motion_plan_request << std::endl;
ASSERT_TRUE(planning_service_client.call(mplan_req, mplan_res));
ASSERT_EQ(mplan_res.error_code.val, mplan_res.error_code.SUCCESS);
EXPECT_GT(mplan_res.trajectory.joint_trajectory.points.size(), 0);
moveit_msgs::DisplayTrajectory d;
d.model_id = scene.getRobotModel()->getName();
d.trajectory_start = mplan_res.trajectory_start;
d.trajectory = mplan_res.trajectory;
pub.publish(d);
ros::Duration(0.5).sleep();
}