int todos_testes() {
_verify(teste_basico);
_verify(teste_tres_elementos);
_verify(teste_dojo_puzzle);
return 0;
}
bool NSettingsDownload::verify(QString& msg)
{
bool r = _verify(fnfmtEdit, msg);
if (r)
r = _verify(regexpEdit, msg);
return r;
}
int all_tests() {
_verify(test_1_to_roman);
_verify(test_2_to_roman);
_verify(test_3_to_roman);
_verify(test_4_to_roman);
_verify(test_5_to_roman);
return 0;
}
int main(int argc, char const* argv[])
{
int successes = 0, failures = 0;
_verify(testInit, successes, failures);
_verify(testAppend, successes, failures);
_verify(testInsert, successes, failures);
printf("\n%d/%d TESTS PASSED.\n", successes, successes + failures);
return failures ? 1 : 0;
}
static void _zero_cycle(struct fixture *f, uint64_t b, uint64_t e)
{
_verify(f, b, e, INIT_PATTERN);
_do_zero(f, b, e);
_reopen(f);
_verify(f, b < 128 ? 0 : b - 128, b, INIT_PATTERN);
_verify_zeroes(f, b, e);
_verify(f, e, _min(e + 128, _max_byte()), INIT_PATTERN);
}
static void _set_cycle(struct fixture *f, uint64_t b, uint64_t e)
{
uint8_t val = random();
_verify(f, b, e, INIT_PATTERN);
_do_set(f, b, e, val);
_reopen(f);
_verify(f, b < 128 ? 0 : b - 128, b, INIT_PATTERN);
_verify_set(f, b, e, val);
_verify(f, e, _min(e + 128, _max_byte()), INIT_PATTERN);
}
static void _rwv_cycle(struct fixture *f, uint64_t b, uint64_t e)
{
uint8_t pat = _random_pattern();
_verify(f, b, e, INIT_PATTERN);
_do_write(f, b, e, pat);
_reopen(f);
_verify(f, b < 128 ? 0 : b - 128, b, INIT_PATTERN);
_verify(f, b, e, pat);
_verify(f, e, _min(e + 128, _max_byte()), INIT_PATTERN);
}
bool TestDataflowGraph::_testReverseSsa()
{
status << "Testing SSA then back Dataflow" << std::endl;
for( StringVector::const_iterator file = _files.begin();
file != _files.end(); ++file )
{
status << " For File: " << *file << std::endl;
ir::Module module( *file );
for( ir::Module::KernelMap::iterator
ki = module.kernels.begin();
ki != module.kernels.end(); ++ki )
{
ir::PTXKernel& kernel = static_cast< ir::PTXKernel& >( *(ki->second) );
status << " For Kernel: " << kernel.name << std::endl;
ir::PTXKernel::assignRegisters( *kernel.cfg() );
kernel.dfg()->compute();
kernel.dfg()->toSsa();
kernel.dfg()->fromSsa();
if( !_verify( *kernel.dfg() ) )
{
return false;
}
}
}
status << " Test Passed" << std::endl;
return true;
}
boolean VC0706::motionDetected(void)
{
if (_read(4, 200) != 4) {
return false;
}
if (!_verify(VC0706_COMM_MOTION_DETECTED))
return false;
return true;
}
static PyObject *
verifying_subscriptions(verify *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"required", "provided", NULL};
PyObject *required, *provided;
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist,
&required, &provided))
return NULL;
if (_verify(self) < 0)
return NULL;
return _subscriptions((lookup *)self, required, provided);
}
static PyObject *
verifying_queryAdapter(verify *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"object", "provided", "name", "default", NULL};
PyObject *object, *provided, *name=NULL, *default_=NULL;
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist,
&object, &provided, &name, &default_))
return NULL;
if (_verify(self) < 0)
return NULL;
return _adapter_hook((lookup *)self, provided, object, name, default_);
}
int main()
{
response_struct result;
char *api_key = "API_KEY";
char *api_secret = "API_SECRET";
user_opt user_info = user_opt_init(api_key, api_secret);
verify_opt verify_info = verify_opt_init();
verify_info.handle_key = "HANDEL_KEY";
result = _verify(&user_info, &verify_info);
print_result(result);
return 0;
}
static PyObject *
verifying_lookup1(verify *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"required", "provided", "name", "default", NULL};
PyObject *required, *provided, *name=NULL, *default_=NULL;
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist,
&required, &provided, &name, &default_))
return NULL;
if (_verify(self) < 0)
return NULL;
return _lookup1((lookup *)self, required, provided, name, default_);
}
bool TestDataflowGraph::_testReverseSsa()
{
status << "Testing SSA then back Dataflow" << std::endl;
for( StringVector::const_iterator file = _files.begin();
file != _files.end(); ++file )
{
status << " For File: " << *file << std::endl;
ir::Module module;
try
{
module.load( *file );
}
catch(parser::PTXParser::Exception& e)
{
if(e.error == parser::PTXParser::State::NotVersion2_1)
{
status << " Skipping file with incompatible ptx version."
<< std::endl;
continue;
}
status << "Load module failed with exception: "
<< e.what() << std::endl;
return false;
}
for( ir::Module::KernelMap::const_iterator
ki = module.kernels().begin();
ki != module.kernels().end(); ++ki )
{
ir::PTXKernel& kernel = static_cast< ir::PTXKernel& >(
*module.getKernel( ki->first ) );
status << " For Kernel: " << kernel.name << std::endl;
analysis::DataflowGraph dfg;
dfg.analyze( kernel );
dfg.toSsa();
dfg.fromSsa();
if( !_verify( dfg ) )
{
return false;
}
}
}
status << " Test Passed" << std::endl;
return true;
}
char * rpmVerifyString(uint32_t verifyResult, const char *pad)
{
char *fmt = NULL;
rasprintf(&fmt, "%s%s%s%s%s%s%s%s%s",
_verify(RPMVERIFY_FILESIZE, "S", pad),
_verify(RPMVERIFY_MODE, "M", pad),
_verifyfile(RPMVERIFY_FILEDIGEST, "5", pad),
_verify(RPMVERIFY_RDEV, "D", pad),
_verifylink(RPMVERIFY_LINKTO, "L", pad),
_verify(RPMVERIFY_USER, "U", pad),
_verify(RPMVERIFY_GROUP, "G", pad),
_verify(RPMVERIFY_MTIME, "T", pad),
_verify(RPMVERIFY_CAPS, "P", pad));
return fmt;
}
boolean VC0706::_task(uint8_t cmd[], uint8_t cmdLen, uint8_t respBytes, uint8_t timeOut, boolean flushflag, boolean verify)
{
if (flushflag) {
while(vc->available()){
uint8_t tmp = vc->read();
}
}
_send(cmd, cmdLen);
if (_read(respBytes, timeOut) != respBytes) {
DBG("read error");
return false;
}
if(verify){
if (_verify(cmd[0])){
DBG("verify error");
return false;
}
}
return true;
}
/** \ingroup rpmcli
* Verify file attributes (including file digest).
* @param vf file data to verify
* #param spew should verify results be printed?
* @return 0 on success (or not installed), 1 on error
*/
static int rpmvfVerify(rpmvf vf, int spew)
/*@globals h_errno, fileSystem, internalState @*/
/*@modifies vf, fileSystem, internalState @*/
{
rpmVerifyAttrs res = RPMVERIFY_NONE;
struct stat sb;
int ec = 0;
/* Check to see if the file was installed - if not pretend all is OK. */
switch (vf->fstate) {
default:
case RPMFILE_STATE_NETSHARED:
case RPMFILE_STATE_REPLACED:
case RPMFILE_STATE_NOTINSTALLED:
case RPMFILE_STATE_WRONGCOLOR:
goto exit;
/*@notreached@*/ break;
case RPMFILE_STATE_NORMAL:
break;
}
assert(vf->fn != NULL);
if (vf->fn == NULL || Lstat(vf->fn, &sb) != 0) {
res |= RPMVERIFY_LSTATFAIL;
ec = 1;
goto exit;
}
/* Not all attributes of non-regular files can be verified. */
if (S_ISDIR(sb.st_mode))
vf->vflags &= ~(RPMVERIFY_FDIGEST | RPMVERIFY_FILESIZE | RPMVERIFY_MTIME |
RPMVERIFY_LINKTO | RPMVERIFY_HMAC);
else if (S_ISLNK(sb.st_mode)) {
vf->vflags &= ~(RPMVERIFY_FDIGEST | RPMVERIFY_FILESIZE | RPMVERIFY_MTIME |
RPMVERIFY_MODE | RPMVERIFY_HMAC);
#if CHOWN_FOLLOWS_SYMLINK
vf->vflags &= ~(RPMVERIFY_USER | RPMVERIFY_GROUP);
#endif
}
else if (S_ISFIFO(sb.st_mode))
vf->vflags &= ~(RPMVERIFY_FDIGEST | RPMVERIFY_FILESIZE | RPMVERIFY_MTIME |
RPMVERIFY_LINKTO | RPMVERIFY_HMAC);
else if (S_ISCHR(sb.st_mode))
vf->vflags &= ~(RPMVERIFY_FDIGEST | RPMVERIFY_FILESIZE | RPMVERIFY_MTIME |
RPMVERIFY_LINKTO | RPMVERIFY_HMAC);
else if (S_ISBLK(sb.st_mode))
vf->vflags &= ~(RPMVERIFY_FDIGEST | RPMVERIFY_FILESIZE | RPMVERIFY_MTIME |
RPMVERIFY_LINKTO | RPMVERIFY_HMAC);
else
vf->vflags &= ~(RPMVERIFY_LINKTO);
if (vf->vflags & (RPMVERIFY_FDIGEST | RPMVERIFY_HMAC)) {
if (vf->digest == NULL || vf->dlen == 0)
res |= RPMVERIFY_FDIGEST;
else {
/* XXX If --nofdigest, then prelinked library sizes fail to verify. */
unsigned char * fdigest = memset(alloca(vf->dlen), 0, vf->dlen);
size_t fsize = 0;
#define _mask (RPMVERIFY_FDIGEST|RPMVERIFY_HMAC)
unsigned dflags = (vf->vflags & _mask) == RPMVERIFY_HMAC
? 0x2 : 0x0;
#undef _mask
int rc = dodigest(vf->dalgo, vf->fn, fdigest, dflags, &fsize);
sb.st_size = fsize;
if (rc)
res |= (RPMVERIFY_READFAIL|RPMVERIFY_FDIGEST);
else
if (memcmp(fdigest, vf->digest, vf->dlen))
res |= RPMVERIFY_FDIGEST;
}
}
if (vf->vflags & RPMVERIFY_LINKTO) {
char linkto[1024+1];
int size = 0;
if ((size = Readlink(vf->fn, linkto, sizeof(linkto)-1)) == -1)
res |= (RPMVERIFY_READLINKFAIL|RPMVERIFY_LINKTO);
else {
linkto[size] = '\0';
if (vf->flink == NULL || strcmp(linkto, vf->flink))
res |= RPMVERIFY_LINKTO;
}
}
if (vf->vflags & RPMVERIFY_FILESIZE) {
if (sb.st_size != vf->sb.st_size)
res |= RPMVERIFY_FILESIZE;
}
if (vf->vflags & RPMVERIFY_MODE) {
/* XXX AIX has sizeof(mode_t) > sizeof(unsigned short) */
unsigned short metamode = (unsigned short)vf->sb.st_mode;
unsigned short filemode = (unsigned short)sb.st_mode;
/* Comparing type of %ghost files is meaningless, but perms are OK. */
if (vf->fflags & RPMFILE_GHOST) {
metamode &= ~0xf000;
filemode &= ~0xf000;
}
if (metamode != filemode)
res |= RPMVERIFY_MODE;
}
if (vf->vflags & RPMVERIFY_RDEV) {
if (S_ISCHR(vf->sb.st_mode) != S_ISCHR(sb.st_mode)
|| S_ISBLK(vf->sb.st_mode) != S_ISBLK(sb.st_mode))
res |= RPMVERIFY_RDEV;
else if (S_ISDEV(vf->sb.st_mode) && S_ISDEV(sb.st_mode)) {
rpmuint16_t st_rdev = (rpmuint16_t)(sb.st_rdev & 0xffff);
rpmuint16_t frdev = (rpmuint16_t)(vf->sb.st_rdev & 0xffff);
if (st_rdev != frdev)
res |= RPMVERIFY_RDEV;
}
}
if (vf->vflags & RPMVERIFY_MTIME) {
if (sb.st_mtime != vf->sb.st_mtime)
res |= RPMVERIFY_MTIME;
}
if (vf->vflags & RPMVERIFY_USER) {
const char * fuser = uidToUname(sb.st_uid);
if (fuser == NULL || vf->fuser == NULL || strcmp(fuser, vf->fuser))
res |= RPMVERIFY_USER;
}
if (vf->vflags & RPMVERIFY_GROUP) {
const char * fgroup = gidToGname(sb.st_gid);
if (fgroup == NULL || vf->fgroup == NULL || strcmp(fgroup, vf->fgroup))
res |= RPMVERIFY_GROUP;
}
exit:
if (spew) { /* XXX no output w verify(...) probe. */
char buf[BUFSIZ];
char * t = buf;
char * te = t;
*te = '\0';
if (ec) {
if (!(vf->fflags & (RPMFILE_MISSINGOK|RPMFILE_GHOST))
|| rpmIsVerbose())
{
sprintf(te, _("missing %c %s"),
((vf->fflags & RPMFILE_CONFIG) ? 'c' :
(vf->fflags & RPMFILE_DOC) ? 'd' :
(vf->fflags & RPMFILE_GHOST) ? 'g' :
(vf->fflags & RPMFILE_LICENSE) ? 'l' :
(vf->fflags & RPMFILE_PUBKEY) ? 'P' :
(vf->fflags & RPMFILE_README) ? 'r' : ' '),
vf->fn);
if ((res & RPMVERIFY_LSTATFAIL) != 0 && errno != ENOENT) {
te += strlen(te);
sprintf(te, " (%s)", strerror(errno));
}
}
} else if (res || rpmIsVerbose()) {
/*@observer@*/ static const char aok[] = ".";
/*@observer@*/ static const char unknown[] = "?";
#define _verify(_RPMVERIFY_F, _C) \
((res & _RPMVERIFY_F) ? _C : aok)
#define _verifylink(_RPMVERIFY_F, _C) \
((res & RPMVERIFY_READLINKFAIL) ? unknown : \
(res & _RPMVERIFY_F) ? _C : aok)
#define _verifyfile(_RPMVERIFY_F, _C) \
((res & RPMVERIFY_READFAIL) ? unknown : \
(res & _RPMVERIFY_F) ? _C : aok)
const char * digest = _verifyfile(RPMVERIFY_FDIGEST, "5");
const char * size = _verify(RPMVERIFY_FILESIZE, "S");
const char * link = _verifylink(RPMVERIFY_LINKTO, "L");
const char * mtime = _verify(RPMVERIFY_MTIME, "T");
const char * rdev = _verify(RPMVERIFY_RDEV, "D");
const char * user = _verify(RPMVERIFY_USER, "U");
const char * group = _verify(RPMVERIFY_GROUP, "G");
const char * mode = _verify(RPMVERIFY_MODE, "M");
#undef _verifyfile
#undef _verifylink
#undef _verify
sprintf(te, "%s%s%s%s%s%s%s%s %c %s",
size, mode, digest, rdev, link, user, group, mtime,
((vf->fflags & RPMFILE_CONFIG) ? 'c' :
(vf->fflags & RPMFILE_DOC) ? 'd' :
(vf->fflags & RPMFILE_GHOST) ? 'g' :
(vf->fflags & RPMFILE_LICENSE) ? 'l' :
(vf->fflags & RPMFILE_PUBKEY) ? 'P' :
(vf->fflags & RPMFILE_README) ? 'r' : ' '),
vf->fn);
}
if (t && *t)
rpmlog(RPMLOG_NOTICE, "%s\n", t);
}
return (res != 0);
}
int main(){
OggVorbis_File ov;
int i,ret;
ogg_int64_t pcmlength;
double timelength;
char *bigassbuffer;
int dummy;
int hs=0;
#ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */
_setmode( _fileno( stdin ), _O_BINARY );
#endif
/* open the file/pipe on stdin */
if(ov_open_callbacks(stdin,&ov,NULL,-1,OV_CALLBACKS_NOCLOSE)<0){
fprintf(stderr,"Could not open input as an OggVorbis file.\n\n");
exit(1);
}
#if 0 /*enable this code to test seeking with halfrate decode */
if(ov_halfrate(&ov,1)){
fprintf(stderr,"Sorry; unable to set half-rate decode.\n\n");
exit(1);
}else
hs=1;
#endif
if(ov_seekable(&ov)){
/* to simplify our own lives, we want to assume the whole file is
stereo. Verify this to avoid potentially mystifying users
(pissing them off is OK, just don't confuse them) */
for(i=0;i<ov.links;i++){
vorbis_info *vi=ov_info(&ov,i);
if(vi->channels!=2){
fprintf(stderr,"Sorry; right now seeking_test can only use Vorbis files\n"
"that are entirely stereo.\n\n");
exit(1);
}
}
/* because we want to do sample-level verification that the seek
does what it claimed, decode the entire file into memory */
pcmlength=ov_pcm_total(&ov,-1);
timelength=ov_time_total(&ov,-1);
bigassbuffer=malloc((pcmlength>>hs)*2); /* w00t */
i=0;
while(i<(pcmlength>>hs)*2){
int ret=ov_read(&ov,bigassbuffer+i,((pcmlength>>hs)*2)-i,1,1,1,&dummy);
if(ret<0){
fprintf(stderr,"Error reading file.\n");
exit(1);
}
if(ret){
i+=ret;
}else{
pcmlength=(i/2)<<hs;
}
fprintf(stderr,"\rloading.... [%ld left] ",
(long)((pcmlength>>hs)*2-i));
}
{
ogg_int64_t length=ov.end;
fprintf(stderr,"\rtesting raw seeking to random places in %ld bytes....\n",
(long)length);
for(i=0;i<1000;i++){
ogg_int64_t val=(double)rand()/RAND_MAX*length;
fprintf(stderr,"\r\t%d [raw position %ld]... ",i,(long)val);
ret=ov_raw_seek(&ov,val);
if(ret<0){
fprintf(stderr,"seek failed: %d\n",ret);
exit(1);
}
_verify(&ov,val,-1,-1.,pcmlength,bigassbuffer);
}
}
fprintf(stderr,"\r");
{
fprintf(stderr,"testing pcm page seeking to random places in %ld samples....\n",
(long)pcmlength);
for(i=0;i<1000;i++){
ogg_int64_t val= i==0?(ogg_int64_t)0:(double)rand()/RAND_MAX*pcmlength;
fprintf(stderr,"\r\t%d [pcm position %ld]... ",i,(long)val);
ret=ov_pcm_seek_page(&ov,val);
if(ret<0){
fprintf(stderr,"seek failed: %d\n",ret);
exit(1);
}
_verify(&ov,-1,val,-1.,pcmlength,bigassbuffer);
}
}
fprintf(stderr,"\r");
{
fprintf(stderr,"testing pcm exact seeking to random places in %f seconds....\n",
timelength);
for(i=0;i<1000;i++){
ogg_int64_t val= i==0?(ogg_int64_t)0:(double)rand()/RAND_MAX*pcmlength;
fprintf(stderr,"\r\t%d [pcm position %ld]... ",i,(long)val);
ret=ov_pcm_seek(&ov,val);
if(ret<0){
fprintf(stderr,"seek failed: %d\n",ret);
exit(1);
}
if(ov_pcm_tell(&ov)!=((val>>hs)<<hs)){
fprintf(stderr,"Declared position didn't perfectly match request: %ld != %ld\n",
(long)val,(long)ov_pcm_tell(&ov));
exit(1);
}
_verify(&ov,-1,val,-1.,pcmlength,bigassbuffer);
}
}
fprintf(stderr,"\r");
{
fprintf(stderr,"testing time page seeking to random places in %f seconds....\n",
timelength);
for(i=0;i<1000;i++){
double val=(double)rand()/RAND_MAX*timelength;
fprintf(stderr,"\r\t%d [time position %f]... ",i,val);
ret=ov_time_seek_page(&ov,val);
if(ret<0){
fprintf(stderr,"seek failed: %d\n",ret);
exit(1);
}
_verify(&ov,-1,-1,val,pcmlength,bigassbuffer);
}
}
fprintf(stderr,"\r");
{
fprintf(stderr,"testing time exact seeking to random places in %f seconds....\n",
timelength);
for(i=0;i<1000;i++){
double val=(double)rand()/RAND_MAX*timelength;
fprintf(stderr,"\r\t%d [time position %f]... ",i,val);
ret=ov_time_seek(&ov,val);
if(ret<0){
fprintf(stderr,"seek failed: %d\n",ret);
exit(1);
}
if(ov_time_tell(&ov)<val-1 || ov_time_tell(&ov)>val+1){
fprintf(stderr,"Declared position didn't perfectly match request: %f != %f\n",
val,ov_time_tell(&ov));
exit(1);
}
_verify(&ov,-1,-1,val,pcmlength,bigassbuffer);
}
}
fprintf(stderr,"\r \nOK.\n\n");
}else{
bool TestDataflowGraph::_testGeneric()
{
status << "Testing Generic Dataflow" << std::endl;
hydrazine::Timer timer;
timer.start();
StringVector usedFiles;
for( unsigned int i = 0, e = _files.size(); i != e; ++i )
{
if( timer.seconds() > timeLimit ) break;
unsigned int index = random() % _files.size();
std::string file = _files[ index ];
status << " For File: " << file << std::endl;
ir::Module module;
try
{
module.load( file );
}
catch(parser::PTXParser::Exception& e)
{
if(e.error == parser::PTXParser::State::NotVersion2_1)
{
status << " Skipping file with incompatible ptx version."
<< std::endl;
continue;
}
status << "Load module failed with exception: "
<< e.what() << std::endl;
return false;
}
for( ir::Module::KernelMap::const_iterator
ki = module.kernels().begin();
ki != module.kernels().end(); ++ki )
{
ir::PTXKernel& kernel = static_cast< ir::PTXKernel& >(
*module.getKernel( ki->first ) );
status << " For Kernel: " << kernel.name << std::endl;
analysis::DataflowGraph dfg;
dfg.analyze( kernel );
if( !_verify( dfg ) )
{
return false;
}
}
usedFiles.push_back( file );
}
_files = usedFiles;
status << " Test Passed" << std::endl;
return true;
}
void create_same_memory(int size, int num, int unit)
{
char buf[BUFSIZ];
int i, j, k;
int status;
int *child;
long ps, pages;
ps = sysconf(_SC_PAGE_SIZE);
pages = 1024 * 1024 / ps;
child = malloc(num);
if (child == NULL)
tst_brkm(TBROK | TERRNO, cleanup, "malloc");
memory = malloc(num * sizeof(**memory));
if (memory == NULL)
tst_brkm(TBROK | TERRNO, cleanup, "malloc");
/* Don't call cleanup in those children. Instead, do a cleanup from the
parent after fetched children's status. */
switch (child[0] = fork()) {
case -1:
tst_brkm(TBROK | TERRNO, cleanup, "fork");
case 0:
tst_resm(TINFO, "child 0 stops.");
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child 0 continues...");
tst_resm(TINFO, "child 0 allocates %d MB filled with 'c'.",
size);
memory[0] = malloc(size / unit * sizeof(*memory));
if (memory[0] == NULL)
tst_brkm(TBROK | TERRNO, tst_exit, "malloc");
for (j = 0; j * unit < size; j++) {
memory[0][j] = mmap(NULL, unit * MB,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (memory[0][j] == MAP_FAILED)
tst_brkm(TBROK | TERRNO, tst_exit, "mmap");
#ifdef HAVE_MADV_MERGEABLE
if (madvise(memory[0][j], unit * MB, MADV_MERGEABLE)
== -1)
tst_brkm(TBROK | TERRNO, tst_exit, "madvise");
#endif
for (i = 0; i < unit * MB; i++)
memory[0][j][i] = 'c';
}
tst_resm(TINFO, "child 0 stops.");
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child 0 continues...");
_verify('c', 0, 0, size / unit, 0, unit * MB);
tst_resm(TINFO, "child 0 changes memory content to 'd'.");
for (j = 0; j < size / unit; j++) {
for (i = 0; i < unit * MB; i++)
memory[0][j][i] = 'd';
}
/* Unmerge. */
tst_resm(TINFO, "child 0 stops.");
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child 0 continues...");
_verify('d', 0, 0, size / unit, 0, unit * MB);
/* Stop. */
tst_resm(TINFO, "child 0 stops.");
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child 0 continues...");
exit(0);
}
switch (child[1] = fork()) {
case -1:
tst_brkm(TBROK | TERRNO, cleanup, "fork");
case 0:
tst_resm(TINFO, "child 1 stops.");
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child 1 continues...");
tst_resm(TINFO, "child 1 allocates %d MB filled with 'a'.",
size);
memory[1] = malloc(size / unit * sizeof(*memory));
if (memory[1] == NULL)
tst_brkm(TBROK | TERRNO, tst_exit, "malloc");
for (j = 0; j < size / unit; j++) {
memory[1][j] = mmap(NULL, unit * MB,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (memory[1][j] == MAP_FAILED)
tst_brkm(TBROK | TERRNO, tst_exit, "mmap");
#ifdef HAVE_MADV_MERGEABLE
if (madvise(memory[1][j], unit * MB, MADV_MERGEABLE)
== -1)
tst_brkm(TBROK | TERRNO, tst_exit, "madvise");
#endif
for (i = 0; i < unit * MB; i++)
memory[1][j][i] = 'a';
}
tst_resm(TINFO, "child 1 stops.");
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child 1 continues...");
_verify('a', 1, 0, size / unit, 0, unit * MB);
tst_resm(TINFO, "child 1 changes memory content to 'b'.");
for (j = 0; j < size / unit; j++) {
for (i = 0; i < unit * MB; i++)
memory[1][j][i] = 'b';
}
tst_resm(TINFO, "child 1 stops.");
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child 1 continues...");
_verify('b', 1, 0, size / unit, 0, unit * MB);
tst_resm(TINFO, "child 1 changes memory content to 'd'");
for (j = 0; j < size / unit; j++) {
for (i = 0; i < unit * MB; i++)
memory[1][j][i] = 'd';
}
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child 1 continues...");
_verify('d', 1, 0, size / unit, 0, unit * MB);
tst_resm(TINFO, "child 1 changes one page to 'e'.");
memory[1][size / unit - 1][unit * MB - 1] = 'e';
/* Unmerge. */
tst_resm(TINFO, "child 1 stops.");
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child 1 continues...");
_verify('e', 1, size / unit - 1, size / unit,
unit * MB - 1, unit * MB);
_verify('d', 1, 0, size / unit - 1, 0, unit * MB - 1);
/* Stop. */
tst_resm(TINFO, "child 1 stops.");
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child 1 continues...");
exit(0);
}
for (k = 2; k < num; k++) {
switch (child[k] = fork()) {
case -1:
tst_brkm(TBROK | TERRNO, cleanup, "fork");
case 0:
tst_resm(TINFO, "child %d stops.", k);
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child %d continues...", k);
tst_resm(TINFO, "child %d allocates %d "
"MB filled with 'a'.", k, size);
memory[k] = malloc(size / unit * sizeof(*memory));
if (memory[k] == NULL)
tst_brkm(TBROK | TERRNO, tst_exit, "malloc");
for (j = 0; j < size / unit; j++) {
memory[k][j] = mmap(NULL, unit * MB,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS
| MAP_PRIVATE, -1, 0);
if (memory[k][j] == MAP_FAILED)
tst_brkm(TBROK | TERRNO, cleanup,
"mmap");
#ifdef HAVE_MADV_MERGEABLE
if (madvise(memory[k][j], unit * MB,
MADV_MERGEABLE) == -1)
tst_brkm(TBROK | TERRNO, cleanup,
"madvise");
#endif
for (i = 0; i < unit * MB; i++)
memory[k][j][i] = 'a';
}
tst_resm(TINFO, "child %d stops.", k);
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child %d continues...", k);
tst_resm(TINFO, "child %d changes memory content to "
"'d'", k);
for (j = 0; j < size / unit; j++) {
for (i = 0; i < unit * MB; i++)
memory[k][j][i] = 'd';
}
/* Unmerge. */
tst_resm(TINFO, "child %d stops.", k);
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child %d continues...", k);
/* Stop. */
tst_resm(TINFO, "child %d stops.", k);
if (raise(SIGSTOP) == -1)
tst_brkm(TBROK | TERRNO, tst_exit, "kill");
tst_resm(TINFO, "child %d continues...", k);
exit(0);
}
}
tst_resm(TINFO, "KSM merging...");
write_file(PATH_KSM "run", "1");
snprintf(buf, BUFSIZ, "%ld", size * pages * num);
write_file(PATH_KSM "pages_to_scan", buf);
write_file(PATH_KSM "sleep_millisecs", "0");
tst_resm(TINFO, "wait for all children to stop.");
for (k = 0; k < num; k++) {
if (waitpid(child[k], &status, WUNTRACED) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "waitpid");
if (!WIFSTOPPED(status))
tst_brkm(TBROK, cleanup, "child %d was not stopped.",
k);
}
tst_resm(TINFO, "resume all children.");
for (k = 0; k < num; k++) {
if (kill(child[k], SIGCONT) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "kill child[%d]", k);
}
_group_check(1, 2, size * num * pages - 2, 0, 0, 0, size * pages * num);
tst_resm(TINFO, "wait for child 1 to stop.");
if (waitpid(child[1], &status, WUNTRACED) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "waitpid");
if (!WIFSTOPPED(status))
tst_brkm(TBROK, cleanup, "child 1 was not stopped.");
/* Child 1 changes all pages to 'b'. */
tst_resm(TINFO, "resume child 1.");
if (kill(child[1], SIGCONT) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "kill");
_group_check(1, 3, size * num * pages - 3, 0, 0, 0, size * pages * num);
tst_resm(TINFO, "wait for child 1 to stop.");
if (waitpid(child[1], &status, WUNTRACED) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "waitpid");
if (!WIFSTOPPED(status))
tst_brkm(TBROK, cleanup, "child 1 was not stopped.");
/* All children change pages to 'd'. */
tst_resm(TINFO, "resume all children.");
for (k = 0; k < num; k++) {
if (kill(child[k], SIGCONT) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "kill child[%d]", k);
}
_group_check(1, 1, size * num * pages - 1, 0, 0, 0, size * pages * num);
tst_resm(TINFO, "wait for all children to stop.");
for (k = 0; k < num; k++) {
if (waitpid(child[k], &status, WUNTRACED) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "waitpid");
if (!WIFSTOPPED(status))
tst_brkm(TBROK, cleanup, "child %d was not stopped.",
k);
}
/* Child 1 changes pages to 'e'. */
tst_resm(TINFO, "resume child 1.");
if (kill(child[1], SIGCONT) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "kill");
_group_check(1, 1, size * num * pages - 2, 0, 1, 0, size * pages * num);
tst_resm(TINFO, "wait for child 1 to stop.");
if (waitpid(child[1], &status, WUNTRACED) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "waitpid");
if (!WIFSTOPPED(status))
tst_brkm(TBROK, cleanup, "child 1 was not stopped.");
tst_resm(TINFO, "resume all children.");
for (k = 0; k < num; k++) {
if (kill(child[k], SIGCONT) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "kill child[%d]", k);
}
tst_resm(TINFO, "KSM unmerging...");
write_file(PATH_KSM "run", "2");
_group_check(2, 0, 0, 0, 0, 0, size * pages * num);
tst_resm(TINFO, "wait for all children to stop.");
for (k = 0; k < num; k++) {
if (waitpid(child[k], &status, WUNTRACED) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "waitpid");
if (!WIFSTOPPED(status))
tst_brkm(TBROK, cleanup, "child %d was not stopped.",
k);
}
tst_resm(TINFO, "resume all children.");
for (k = 0; k < num; k++) {
if (kill(child[k], SIGCONT) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "kill child[%d]", k);
}
tst_resm(TINFO, "stop KSM.");
write_file(PATH_KSM "run", "0");
_group_check(0, 0, 0, 0, 0, 0, size * pages * num);
while (waitpid(-1, &status, WUNTRACED | WCONTINUED) > 0)
if (WEXITSTATUS(status) != 0)
tst_resm(TFAIL, "child exit status is %d",
WEXITSTATUS(status));
}
int main(){
OggVorbis_File ov;
int i,ret;
ogg_int64_t pcmlength;
char *bigassbuffer;
int dummy;
#ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */
_setmode( _fileno( stdin ), _O_BINARY );
_setmode( _fileno( stdout ), _O_BINARY );
#endif
/* open the file/pipe on stdin */
if(ov_open(stdin,&ov,NULL,-1)<0){
printf("Could not open input as an OggVorbis file.\n\n");
exit(1);
}
if(ov_seekable(&ov)){
/* to simplify our own lives, we want to assume the whole file is
stereo. Verify this to avoid potentially mystifying users
(pissing them off is OK, just don't confuse them) */
for(i=0;i<ov.links;i++){
vorbis_info *vi=ov_info(&ov,i);
if(vi->channels!=2){
printf("Sorry; right now seeking_test can only use Vorbis files\n"
"that are entirely stereo.\n\n");
exit(1);
}
}
/* because we want to do sample-level verification that the seek
does what it claimed, decode the entire file into memory */
fflush(stdout);
pcmlength=ov_pcm_total(&ov,-1);
bigassbuffer=malloc(pcmlength*2); /* w00t */
i=0;
while(i<pcmlength*2){
int ret=ov_read(&ov,bigassbuffer+i,pcmlength*2-i,1,1,1,&dummy);
if(ret<0)continue;
if(ret){
i+=ret;
}else{
pcmlength=i/2;
}
fprintf(stderr,"\rloading.... [%ld left] ",
(long)(pcmlength*2-i));
}
/* Exercise all the real seeking cases; ov_raw_seek,
ov_pcm_seek_page and ov_pcm_seek. time seek is just a wrapper
on pcm_seek */
{
ogg_int64_t length=ov.end;
printf("\rtesting raw seeking to random places in %ld bytes....\n",
(long)length);
for(i=0;i<1000;i++){
ogg_int64_t val=(double)rand()/RAND_MAX*length;
ogg_int64_t pos;
printf("\r\t%d [raw position %ld]... ",i,(long)val);
fflush(stdout);
ret=ov_raw_seek(&ov,val);
if(ret<0){
printf("seek failed: %d\n",ret);
exit(1);
}
_verify(&ov,pos,val,-1,pcmlength,bigassbuffer);
}
}
printf("\r");
{
printf("testing pcm page seeking to random places in %ld samples....\n",
(long)pcmlength);
for(i=0;i<1000;i++){
ogg_int64_t val=(double)rand()/RAND_MAX*pcmlength;
ogg_int64_t pos;
printf("\r\t%d [pcm position %ld]... ",i,(long)val);
fflush(stdout);
ret=ov_pcm_seek_page(&ov,val);
if(ret<0){
printf("seek failed: %d\n",ret);
exit(1);
}
_verify(&ov,pos,-1,val,pcmlength,bigassbuffer);
}
}
printf("\r");
{
ogg_int64_t length=ov.end;
printf("testing pcm exact seeking to random places in %ld samples....\n",
(long)pcmlength);
for(i=0;i<1000;i++){
ogg_int64_t val=(double)rand()/RAND_MAX*pcmlength;
ogg_int64_t pos;
printf("\r\t%d [pcm position %ld]... ",i,(long)val);
fflush(stdout);
ret=ov_pcm_seek(&ov,val);
if(ret<0){
printf("seek failed: %d\n",ret);
exit(1);
}
if(ov_pcm_tell(&ov)!=val){
printf("Declared position didn't perfectly match request: %ld != %ld\n",
(long)val,(long)ov_pcm_tell(&ov));
exit(1);
}
_verify(&ov,pos,-1,val,pcmlength,bigassbuffer);
}
}
printf("\r \nOK.\n\n");
}else{
printf("Standard input was not seekable.\n");
}
ov_clear(&ov);
return 0;
}
/**
* Check file info from header against what's actually installed.
* @param qva parsed query/verify options
* @param ts transaction set
* @param h header to verify
* @return 0 no problems, 1 problems found
*/
static int verifyHeader(QVA_t qva, const rpmts ts, Header h)
{
rpmVerifyAttrs verifyResult = 0;
/* FIX: union? */
rpmVerifyAttrs omitMask = ((qva->qva_flags & VERIFY_ATTRS) ^ VERIFY_ATTRS);
int ec = 0; /* assume no problems */
char *buf = NULL;
int i;
rpmfi fi = rpmfiNew(ts, h, RPMTAG_BASENAMES, RPMFI_FLAGS_VERIFY);
rpmfiInit(fi, 0);
while ((i = rpmfiNext(fi)) >= 0) {
rpmfileAttrs fileAttrs;
int rc;
fileAttrs = rpmfiFFlags(fi);
/* If not verifying %ghost, skip ghost files. */
if (!(qva->qva_fflags & RPMFILE_GHOST)
&& (fileAttrs & RPMFILE_GHOST))
continue;
rc = rpmVerifyFile(ts, fi, &verifyResult, omitMask);
if (rc) {
if (!(fileAttrs & (RPMFILE_MISSINGOK|RPMFILE_GHOST)) || rpmIsVerbose()) {
rasprintf(&buf, _("missing %c %s"),
((fileAttrs & RPMFILE_CONFIG) ? 'c' :
(fileAttrs & RPMFILE_DOC) ? 'd' :
(fileAttrs & RPMFILE_GHOST) ? 'g' :
(fileAttrs & RPMFILE_LICENSE) ? 'l' :
(fileAttrs & RPMFILE_PUBKEY) ? 'P' :
(fileAttrs & RPMFILE_README) ? 'r' : ' '),
rpmfiFN(fi));
if ((verifyResult & RPMVERIFY_LSTATFAIL) != 0 &&
errno != ENOENT) {
char *app;
rasprintf(&app, " (%s)", strerror(errno));
rstrcat(&buf, app);
free(app);
}
ec = rc;
}
} else if (verifyResult || rpmIsVerbose()) {
const char * size, * MD5, * link, * mtime, * mode;
const char * group, * user, * rdev, *caps;
static const char *const aok = ".";
static const char *const unknown = "?";
ec = 1;
#define _verify(_RPMVERIFY_F, _C) \
((verifyResult & _RPMVERIFY_F) ? _C : aok)
#define _verifylink(_RPMVERIFY_F, _C) \
((verifyResult & RPMVERIFY_READLINKFAIL) ? unknown : \
(verifyResult & _RPMVERIFY_F) ? _C : aok)
#define _verifyfile(_RPMVERIFY_F, _C) \
((verifyResult & RPMVERIFY_READFAIL) ? unknown : \
(verifyResult & _RPMVERIFY_F) ? _C : aok)
MD5 = _verifyfile(RPMVERIFY_MD5, "5");
size = _verify(RPMVERIFY_FILESIZE, "S");
link = _verifylink(RPMVERIFY_LINKTO, "L");
mtime = _verify(RPMVERIFY_MTIME, "T");
rdev = _verify(RPMVERIFY_RDEV, "D");
user = _verify(RPMVERIFY_USER, "U");
group = _verify(RPMVERIFY_GROUP, "G");
mode = _verify(RPMVERIFY_MODE, "M");
caps = _verify(RPMVERIFY_CAPS, "P");
#undef _verifyfile
#undef _verifylink
#undef _verify
rasprintf(&buf, "%s%s%s%s%s%s%s%s%s %c %s",
size, mode, MD5, rdev, link, user, group, mtime, caps,
((fileAttrs & RPMFILE_CONFIG) ? 'c' :
(fileAttrs & RPMFILE_DOC) ? 'd' :
(fileAttrs & RPMFILE_GHOST) ? 'g' :
(fileAttrs & RPMFILE_LICENSE) ? 'l' :
(fileAttrs & RPMFILE_PUBKEY) ? 'P' :
(fileAttrs & RPMFILE_README) ? 'r' : ' '),
rpmfiFN(fi));
}
if (buf) {
rpmlog(RPMLOG_NOTICE, "%s\n", buf);
buf = _free(buf);
}
}
rpmfiFree(fi);
return ec;
}