void test_for_error( const char *const format, Args &&... args )
{
CAPTURE( format );
const std::string result = throwing_string_format( format, std::forward<Args>( args )... );
CAPTURE( result );
}
static OSStatus
DER_UTCTimeToCFDate(const SecAsn1Item * utcTime, CFAbsoluteTime *date)
{
char *string = (char *)utcTime->Data;
int year, month, mday, hour, minute, second, hourOff, minOff;
/* Verify time is formatted properly and capture information */
second = 0;
hourOff = 0;
minOff = 0;
CAPTURE(year,string+0,loser);
if (year < 50) {
/* ASSUME that year # is in the 2000's, not the 1900's */
year += 2000;
} else {
year += 1900;
}
CAPTURE(month,string+2,loser);
if ((month == 0) || (month > 12)) goto loser;
CAPTURE(mday,string+4,loser);
if ((mday == 0) || (mday > 31)) goto loser;
CAPTURE(hour,string+6,loser);
if (hour > 23) goto loser;
CAPTURE(minute,string+8,loser);
if (minute > 59) goto loser;
if (ISDIGIT(string[10])) {
CAPTURE(second,string+10,loser);
if (second > 59) goto loser;
string += 2;
}
if (string[10] == '+') {
CAPTURE(hourOff,string+11,loser);
if (hourOff > 23) goto loser;
CAPTURE(minOff,string+13,loser);
if (minOff > 59) goto loser;
} else if (string[10] == '-') {
CAPTURE(hourOff,string+11,loser);
if (hourOff > 23) goto loser;
hourOff = -hourOff;
CAPTURE(minOff,string+13,loser);
if (minOff > 59) goto loser;
minOff = -minOff;
} else if (string[10] != 'Z') {
goto loser;
}
if (hourOff == 0 && minOff == 0) {
*date = CFAbsoluteTimeForGregorianZuluMoment(year, month, mday, hour, minute, second);
} else {
CFTimeZoneRef tz = CFTimeZoneCreateWithTimeIntervalFromGMT(kCFAllocatorDefault, (hourOff * 60 + minOff) * 60);
*date = CFAbsoluteTimeForGregorianMoment(tz, year, month, mday, hour, minute, second);
CFReleaseSafe(tz);
}
return SECSuccess;
loser:
return SECFailure;
}
void mingw_test( const char *const old_pattern, const char *const new_pattern, const T &value )
{
CAPTURE( old_pattern );
CAPTURE( new_pattern );
std::string original_result = cata::string_formatter::raw_string_format( old_pattern, value );
std::string new_result = throwing_string_format( new_pattern, value );
CHECK( original_result == new_result );
}
void importet_test( const int serial, const char *const expected, const char *const format,
Args &&... args )
{
CAPTURE( serial );
CAPTURE( format );
const std::string original_result = cata::string_formatter::raw_string_format( format,
std::forward<Args>( args )... );
const std::string new_result = throwing_string_format( format, std::forward<Args>( args )... );
// The expected string *is* what the raw printf would return.
CHECK( original_result == expected );
CHECK( original_result == new_result );
}
void IS_UNIFORM(
const arma::Col<arma::uword>& actualData,
const arma::uword expectedLowerBound,
const arma::uword expectedUpperBound) {
REQUIRE(arma::all(expectedLowerBound <= actualData));
REQUIRE(arma::all(actualData <= expectedUpperBound));
const arma::Col<arma::uword>& bins = arma::linspace<arma::Col<arma::uword>>(expectedLowerBound, expectedUpperBound, expectedUpperBound - expectedLowerBound + 1);
CAPTURE(bins);
const arma::Col<arma::uword>& histogram = arma::hist(actualData, bins);
CAPTURE(histogram);
REQUIRE((histogram.max() - histogram.min()) < static_cast<arma::uword>(0.05 * static_cast<double>(actualData.n_elem)));
}
void test_new_old_pattern( const char *const old_pattern, const char *const new_pattern,
Args &&...args )
{
CAPTURE( old_pattern );
CAPTURE( new_pattern );
std::string original_result = cata::string_formatter::raw_string_format( old_pattern,
std::forward<Args>( args )... );
std::string old_result = throwing_string_format( old_pattern, std::forward<Args>( args )... );
CHECK( original_result == old_result );
if( new_pattern ) {
std::string new_result = throwing_string_format( new_pattern, std::forward<Args>( args )... );
CHECK( original_result == new_result );
}
}
void test_for_expected( const std::string &expected, const char *const format, Args &&... args )
{
CAPTURE( format );
const std::string result = throwing_string_format( format, std::forward<Args>( args )... );
CHECK( result == expected );
}
bool validate_ppf_results(rs2::frame origin_depth, rs2::frame result_depth, const ppf_test_config& reference_data, size_t frame_idx)
{
std::vector<uint16_t> diff2orig;
std::vector<uint16_t> diff2ref;
// Basic sanity scenario with no filters applied.
// validating domain transform in/out conversion. Requiring input=output
bool domain_transform_only = (reference_data.downsample_scale == 1) &&
(!reference_data.spatial_filter) && (!reference_data.temporal_filter);
auto result_profile = result_depth.get_profile().as<rs2::video_stream_profile>();
REQUIRE(result_profile);
CAPTURE(result_profile.width());
CAPTURE(result_profile.height());
REQUIRE(result_profile.width() == reference_data.output_res_x);
REQUIRE(result_profile.height() == reference_data.output_res_y);
auto pixels = result_profile.width()*result_profile.height();
diff2ref.resize(pixels);
if (domain_transform_only)
diff2orig.resize(pixels);
// Pixel-by-pixel comparison of the resulted filtered depth vs data ercorded with external tool
auto v1 = reinterpret_cast<const uint16_t*>(result_depth.get_data());
auto v2 = reinterpret_cast<const uint16_t*>(reference_data._output_frames[frame_idx].data());
for (auto i = 0; i < pixels; i++)
{
uint16_t diff = std::abs(*v1++ - *v2++);
diff2ref[i] = diff;
}
// validating depth<->disparity domain transformation is lostless.
if (domain_transform_only)
REQUIRE(profile_diffs("./DomainTransform.txt",diff2orig, 0, 0, frame_idx));
// Validate the filters
// The differences between the reference code and librealsense implementation are byte-compared below
return profile_diffs("./Filterstransform.txt", diff2ref, 0.f, 0, frame_idx);
}
// Verify that the named monster has the expected effective speed, not reduced
// due to wasted motion from shambling.
static void check_shamble_speed( const std::string monster_type, const tripoint &destination )
{
// Scale the scaling factor based on the ratio of diagonal to cardinal steps.
const float slope = get_normalized_angle( {0, 0}, {destination.x, destination.y} );
const float diagonal_multiplier = 1.0 + (get_option<bool>( "CIRCLEDIST" ) ? (slope * 0.41) : 0.0);
INFO( monster_type << " " << destination );
// Wandering makes things nondeterministic, so look at the distribution rather than a target number.
statistics move_stats;
for( int i = 0; i < 10; ++i ) {
move_stats.add( moves_to_destination( monster_type, {0, 0, 0}, destination ) );
if( (move_stats.avg() / (10000.0 * diagonal_multiplier)) ==
Approx(1.0).epsilon(0.02) ) {
break;
}
}
CAPTURE(slope);
CAPTURE(move_stats.avg());
INFO(diagonal_multiplier);
CHECK( (move_stats.avg() / (10000.0 * diagonal_multiplier)) ==
Approx(1.0).epsilon(0.02) );
}
void IS_UNIFORM(
const arma::Col<double>& actualData,
const double expectedLowerBound,
const double expectedUpperBound) {
REQUIRE(arma::all(expectedLowerBound <= actualData));
REQUIRE(arma::all(actualData <= expectedUpperBound));
const arma::uword numberOfBins = 10;
CAPTURE(numberOfBins);
const double binDistance = (expectedUpperBound - expectedLowerBound) / numberOfBins;
CAPTURE(binDistance);
const arma::Col<double>& bins = arma::linspace<arma::Col<double>>(expectedLowerBound, expectedUpperBound - binDistance, numberOfBins) + binDistance / 2;
CAPTURE(bins);
const arma::Col<arma::uword>& histogram = arma::hist(actualData, bins);
CAPTURE(histogram);
REQUIRE((histogram.max() - histogram.min()) < static_cast<arma::uword>(0.05 * static_cast<double>(actualData.n_elem)));
}
static void test_shooting_scenario( npc &shooter, int min_quickdraw_range,
int min_good_range, int max_good_range )
{
{
dispersion_sources dispersion = get_dispersion( shooter, 0 );
std::array<statistics, 5> minimum_stats = firing_test( dispersion, min_quickdraw_range, {{ 0.2, 0.1, -1, -1, -1 }} );
INFO( dispersion );
INFO( "Range: " << min_quickdraw_range );
INFO( "Max aim speed: " << shooter.aim_per_move( shooter.weapon, MAX_RECOIL ) );
INFO( "Min aim speed: " << shooter.aim_per_move( shooter.weapon, shooter.recoil ) );
CAPTURE( minimum_stats[0].n() );
CAPTURE( minimum_stats[0].adj_wald_error() );
CAPTURE( minimum_stats[1].n() );
CAPTURE( minimum_stats[1].adj_wald_error() );
CHECK( minimum_stats[0].avg() < 0.2 );
CHECK( minimum_stats[1].avg() < 0.1 );
}
{
dispersion_sources dispersion = get_dispersion( shooter, 300 );
std::array<statistics, 5> good_stats = firing_test( dispersion, min_good_range, {{ -1, -1, 0.5, -1, -1 }} );
INFO( dispersion );
INFO( "Range: " << min_good_range );
INFO( "Max aim speed: " << shooter.aim_per_move( shooter.weapon, MAX_RECOIL ) );
INFO( "Min aim speed: " << shooter.aim_per_move( shooter.weapon, shooter.recoil ) );
CAPTURE( good_stats[2].n() );
CAPTURE( good_stats[2].adj_wald_error() );
CHECK( good_stats[2].avg() > 0.5 );
}
{
dispersion_sources dispersion = get_dispersion( shooter, 500 );
std::array<statistics, 5> good_stats = firing_test( dispersion, max_good_range, {{ -1, -1, 0.1, -1, -1 }} );
INFO( dispersion );
INFO( "Range: " << max_good_range );
INFO( "Max aim speed: " << shooter.aim_per_move( shooter.weapon, MAX_RECOIL ) );
INFO( "Min aim speed: " << shooter.aim_per_move( shooter.weapon, shooter.recoil ) );
CAPTURE( good_stats[2].n() );
CAPTURE( good_stats[2].adj_wald_error() );
CHECK( good_stats[2].avg() < 0.1 );
}
}
static void test_fast_shooting( npc &shooter, int moves, float hit_rate )
{
const int fast_shooting_range = 3;
const float hit_rate_cap = hit_rate + 0.3;
dispersion_sources dispersion = get_dispersion( shooter, moves );
std::array<statistics, 5> fast_stats = firing_test( dispersion, fast_shooting_range, {{ -1, hit_rate, -1, -1, -1 }} );
std::array<statistics, 5> fast_stats_upper = firing_test( dispersion, fast_shooting_range, {{ -1, hit_rate_cap, -1, -1, -1 }} );
INFO( dispersion );
INFO( "Range: " << fast_shooting_range );
INFO( "Max aim speed: " << shooter.aim_per_move( shooter.weapon, MAX_RECOIL ) );
INFO( "Min aim speed: " << shooter.aim_per_move( shooter.weapon, shooter.recoil ) );
CAPTURE( shooter.weapon.gun_skill().str() );
CAPTURE( shooter.get_skill_level( shooter.weapon.gun_skill() ) );
CAPTURE( shooter.get_dex() );
CAPTURE( to_milliliter( shooter.weapon.volume() ) );
CAPTURE( fast_stats[1].n() );
CAPTURE( fast_stats[1].adj_wald_error() );
CHECK( fast_stats[1].avg() > hit_rate );
CAPTURE( fast_stats_upper[1].n() );
CAPTURE( fast_stats_upper[1].adj_wald_error() );
CHECK( fast_stats_upper[1].avg() < hit_rate_cap );
}
void reporter<specialized>::send(severity s, const char* file, unsigned long line, const char* msg)
{
std::ostringstream os;
if( line )
{
os << file << ':' << line << '\n';
}
os << msg;
const auto failure = os.str();
if( s == severity::fatal )
{
FAIL(failure);
}
else
{
CAPTURE(failure);
CHECK(failure.empty());
}
}
static SECStatus
der_TimeStringToTime(PRTime *dst, const char * string, int generalized)
{
PRExplodedTime genTime;
long hourOff = 0, minOff = 0;
uint16 century;
char signum;
if (string == NULL || dst == NULL) {
PORT_SetError(SEC_ERROR_INVALID_ARGS);
return SECFailure;
}
/* Verify time is formatted properly and capture information */
memset(&genTime, 0, sizeof genTime);
if (generalized == UTC_STRING) {
CAPTURE(genTime.tm_year, string, loser);
century = (genTime.tm_year < 50) ? 20 : 19;
} else {
CAPTURE(century, string, loser);
CAPTURE(genTime.tm_year, string, loser);
}
genTime.tm_year += century * 100;
CAPTURE(genTime.tm_month, string, loser);
if ((genTime.tm_month == 0) || (genTime.tm_month > 12))
goto loser;
/* NSPR month base is 0 */
--genTime.tm_month;
CAPTURE(genTime.tm_mday, string, loser);
if ((genTime.tm_mday == 0) || (genTime.tm_mday > 31))
goto loser;
CAPTURE(genTime.tm_hour, string, loser);
if (genTime.tm_hour > 23)
goto loser;
CAPTURE(genTime.tm_min, string, loser);
if (genTime.tm_min > 59)
goto loser;
if (ISDIGIT(string[0])) {
CAPTURE(genTime.tm_sec, string, loser);
if (genTime.tm_sec > 59)
goto loser;
}
signum = *string++;
if (signum == '+' || signum == '-') {
CAPTURE(hourOff, string, loser);
if (hourOff > 23)
goto loser;
CAPTURE(minOff, string, loser);
if (minOff > 59)
goto loser;
if (signum == '-') {
hourOff = -hourOff;
minOff = -minOff;
}
} else if (signum != 'Z') {
goto loser;
}
/* Convert the GMT offset to seconds and save it in genTime
* for the implode time call.
*/
genTime.tm_params.tp_gmt_offset = (PRInt32)((hourOff * 60L + minOff) * 60L);
*dst = PR_ImplodeTime(&genTime);
return SECSuccess;
loser:
PORT_SetError(SEC_ERROR_INVALID_TIME);
return SECFailure;
}
void statsd_parser_exec(statsd_parser *parser, const char *buffer, size_t len) {
const char *p, *pe;
int cs = parser->cs;
p = buffer;
pe = buffer+len;
/* Exec */
#line 81 "ext/statsd/statsd_parser.c"
{
if ( p == pe )
goto _test_eof;
switch ( cs )
{
tr12:
#line 20 "ext/statsd/statsd_parser.c.rl"
{ EMIT(COUNTER); }
goto st13;
tr15:
#line 14 "ext/statsd/statsd_parser.c.rl"
{ MARK(p); }
#line 17 "ext/statsd/statsd_parser.c.rl"
{ CAPTURE(sample_rate, p); }
#line 20 "ext/statsd/statsd_parser.c.rl"
{ EMIT(COUNTER); }
goto st13;
tr18:
#line 17 "ext/statsd/statsd_parser.c.rl"
{ CAPTURE(sample_rate, p); }
#line 20 "ext/statsd/statsd_parser.c.rl"
{ EMIT(COUNTER); }
goto st13;
tr21:
#line 18 "ext/statsd/statsd_parser.c.rl"
{ EMIT(GAUGE); }
goto st13;
tr23:
#line 19 "ext/statsd/statsd_parser.c.rl"
{ EMIT(TIMER); }
goto st13;
st13:
if ( ++p == pe )
goto _test_eof13;
case 13:
#line 117 "ext/statsd/statsd_parser.c"
switch( (*p) ) {
case 10: goto tr25;
case 58: goto tr26;
}
goto tr24;
tr24:
#line 14 "ext/statsd/statsd_parser.c.rl"
{ MARK(p); }
goto st0;
st0:
if ( ++p == pe )
goto _test_eof0;
case 0:
#line 131 "ext/statsd/statsd_parser.c"
switch( (*p) ) {
case 10: goto st14;
case 58: goto tr2;
}
goto st0;
tr25:
#line 14 "ext/statsd/statsd_parser.c.rl"
{ MARK(p); }
goto st14;
st14:
if ( ++p == pe )
goto _test_eof14;
case 14:
#line 145 "ext/statsd/statsd_parser.c"
switch( (*p) ) {
case 10: goto tr25;
case 58: goto tr27;
}
goto tr24;
tr2:
#line 15 "ext/statsd/statsd_parser.c.rl"
{ CAPTURE(name, p); }
goto st1;
tr26:
#line 14 "ext/statsd/statsd_parser.c.rl"
{ MARK(p); }
#line 15 "ext/statsd/statsd_parser.c.rl"
{ CAPTURE(name, p); }
goto st1;
tr27:
#line 15 "ext/statsd/statsd_parser.c.rl"
{ CAPTURE(name, p); }
#line 14 "ext/statsd/statsd_parser.c.rl"
{ MARK(p); }
goto st1;
st1:
if ( ++p == pe )
goto _test_eof1;
case 1:
#line 171 "ext/statsd/statsd_parser.c"
switch( (*p) ) {
case 10: goto st13;
case 45: goto tr5;
case 124: goto tr6;
}
if ( 48 <= (*p) && (*p) <= 57 )
goto tr5;
goto st2;
st2:
if ( ++p == pe )
goto _test_eof2;
case 2:
if ( (*p) == 10 )
goto st13;
goto st2;
tr5:
#line 14 "ext/statsd/statsd_parser.c.rl"
{ MARK(p); }
goto st3;
st3:
if ( ++p == pe )
goto _test_eof3;
case 3:
#line 195 "ext/statsd/statsd_parser.c"
switch( (*p) ) {
case 10: goto st13;
case 124: goto tr8;
}
if ( 48 <= (*p) && (*p) <= 57 )
goto st3;
goto st2;
tr6:
#line 14 "ext/statsd/statsd_parser.c.rl"
{ MARK(p); }
#line 16 "ext/statsd/statsd_parser.c.rl"
{ CAPTURE(value, p); }
goto st4;
tr8:
#line 16 "ext/statsd/statsd_parser.c.rl"
{ CAPTURE(value, p); }
goto st4;
st4:
if ( ++p == pe )
goto _test_eof4;
case 4:
#line 217 "ext/statsd/statsd_parser.c"
switch( (*p) ) {
case 10: goto st13;
case 99: goto st5;
case 103: goto st10;
case 109: goto st11;
}
goto st2;
st5:
if ( ++p == pe )
goto _test_eof5;
case 5:
switch( (*p) ) {
case 10: goto tr12;
case 124: goto st6;
}
goto st2;
st6:
if ( ++p == pe )
goto _test_eof6;
case 6:
switch( (*p) ) {
case 10: goto st13;
case 64: goto st7;
}
goto st2;
st7:
if ( ++p == pe )
goto _test_eof7;
case 7:
switch( (*p) ) {
case 10: goto tr15;
case 45: goto tr16;
case 46: goto tr17;
}
if ( 48 <= (*p) && (*p) <= 57 )
goto tr16;
goto st2;
tr16:
#line 14 "ext/statsd/statsd_parser.c.rl"
{ MARK(p); }
goto st8;
st8:
if ( ++p == pe )
goto _test_eof8;
case 8:
#line 263 "ext/statsd/statsd_parser.c"
switch( (*p) ) {
case 10: goto tr18;
case 46: goto st9;
}
if ( 48 <= (*p) && (*p) <= 57 )
goto st8;
goto st2;
tr17:
#line 14 "ext/statsd/statsd_parser.c.rl"
{ MARK(p); }
goto st9;
st9:
if ( ++p == pe )
goto _test_eof9;
case 9:
#line 279 "ext/statsd/statsd_parser.c"
if ( (*p) == 10 )
goto tr18;
if ( 48 <= (*p) && (*p) <= 57 )
goto st9;
goto st2;
st10:
if ( ++p == pe )
goto _test_eof10;
case 10:
if ( (*p) == 10 )
goto tr21;
goto st2;
st11:
if ( ++p == pe )
goto _test_eof11;
case 11:
switch( (*p) ) {
case 10: goto st13;
case 115: goto st12;
}
goto st2;
st12:
if ( ++p == pe )
goto _test_eof12;
case 12:
if ( (*p) == 10 )
goto tr23;
goto st2;
}
_test_eof13: cs = 13; goto _test_eof;
_test_eof0: cs = 0; goto _test_eof;
_test_eof14: cs = 14; goto _test_eof;
_test_eof1: cs = 1; goto _test_eof;
_test_eof2: cs = 2; goto _test_eof;
_test_eof3: cs = 3; goto _test_eof;
_test_eof4: cs = 4; goto _test_eof;
_test_eof5: cs = 5; goto _test_eof;
_test_eof6: cs = 6; goto _test_eof;
_test_eof7: cs = 7; goto _test_eof;
_test_eof8: cs = 8; goto _test_eof;
_test_eof9: cs = 9; goto _test_eof;
_test_eof10: cs = 10; goto _test_eof;
_test_eof11: cs = 11; goto _test_eof;
_test_eof12: cs = 12; goto _test_eof;
_test_eof: {}
}
#line 73 "ext/statsd/statsd_parser.c.rl"
}
static OSStatus
DER_UTCTimeToCFDate(const CSSM_DATA_PTR utcTime, CFAbsoluteTime *date)
{
CFGregorianDate gdate;
char *string = (char *)utcTime->Data;
long year, month, mday, hour, minute, second, hourOff, minOff;
CFTimeZoneRef timeZone;
/* Verify time is formatted properly and capture information */
second = 0;
hourOff = 0;
minOff = 0;
CAPTURE(year,string+0,loser);
if (year < 50) {
/* ASSUME that year # is in the 2000's, not the 1900's */
year += 100;
}
CAPTURE(month,string+2,loser);
if ((month == 0) || (month > 12)) goto loser;
CAPTURE(mday,string+4,loser);
if ((mday == 0) || (mday > 31)) goto loser;
CAPTURE(hour,string+6,loser);
if (hour > 23) goto loser;
CAPTURE(minute,string+8,loser);
if (minute > 59) goto loser;
if (ISDIGIT(string[10])) {
CAPTURE(second,string+10,loser);
if (second > 59) goto loser;
string += 2;
}
if (string[10] == '+') {
CAPTURE(hourOff,string+11,loser);
if (hourOff > 23) goto loser;
CAPTURE(minOff,string+13,loser);
if (minOff > 59) goto loser;
} else if (string[10] == '-') {
CAPTURE(hourOff,string+11,loser);
if (hourOff > 23) goto loser;
hourOff = -hourOff;
CAPTURE(minOff,string+13,loser);
if (minOff > 59) goto loser;
minOff = -minOff;
} else if (string[10] != 'Z') {
goto loser;
}
gdate.year = (SInt32)(year + 1900);
gdate.month = month;
gdate.day = mday;
gdate.hour = hour;
gdate.minute = minute;
gdate.second = second;
if (hourOff == 0 && minOff == 0)
timeZone = NULL; /* GMT */
else
{
timeZone = CFTimeZoneCreateWithTimeIntervalFromGMT(NULL, (hourOff * 60 + minOff) * 60);
}
*date = CFGregorianDateGetAbsoluteTime(gdate, timeZone);
if (timeZone)
CFRelease(timeZone);
return SECSuccess;
loser:
return SECFailure;
}
