main() {
reset();
enable_interrupt();
while() {
elegir_luz();
encender_luz();
}
/***** rutina de interrupcion *****/
if (scan_inter () != 1) {
if (shift_reg == FLAG) {
switch (p_buffer) {
case (0) : comienzo = 1;
break;
case (1) : if (comienzo==1) {
p_buffer = 0;
device = gchar();
if ( device == IDENTIFICATIVO) {
acknowledge();
p_out = 0;
wserial( gout () );
more = 1;
}
}
break;
default : if ( device == IDENTIFICATIVO ) {
if (verificar() == NAK) no_acknowledge ();
else {
ack_nak = interpretar ();
if ( ack_nak == ACK ) acknowledge ();
else no_acknowledge ();
}
p_out = 0;
wserial( gout () );
more = 1;
}
break;
}
p_buffer = 0;
}
else pchar(shift_reg);
}
else {
if (more == 0) goto RTI;
wserial( gout () );
if (shift_reg == 'f') {
p_out = 1;
more = 0;
}
}
RTI ();
}
// "chessx.eco.txt" -> "chessx.eco", "chessx.gtm", "chessx.txt"
bool compileAsciiEcoFile(const QString& filenameIn, QString filenameOut, QString gtmFile)
{
// Read in the ECO data
if(!parseAsciiEcoData(filenameIn))
{
return false;
}
filenameOut = QFileInfo(filenameIn).absolutePath() + QDir::separator() + filenameOut;
gtmFile = QFileInfo(filenameIn).absolutePath() + QDir::separator() + gtmFile;
// Write out the main ECO file
QFile file(filenameOut);
file.open(QIODevice::WriteOnly);
QDataStream sout(&file);
sout << COMPILED_ECO_FILE_ID;
sout << ecoPositions;
file.close();
// Write out the GTM (guess-the-move) ECO file
QFile gfile(gtmFile);
gfile.open(QIODevice::WriteOnly);
QDataStream gout(&gfile);
gout << COMPILED_GUESS_FILE_ID;
gout << gtmPositions;
gfile.close();
ecoPositions.clear();
gtmPositions.clear();
return true;
}
void Swall::saveconfig()
{
// seems to work
qDebug() << "Save Config Button was clicked.";
QFile file(cfgfile);
qDebug() << "QFile set to: " << cfgfile;
if (file.open(QIODevice::WriteOnly | QIODevice::Text))
{
qDebug() << "if file open bit";
QTextStream gout(&file);
QMap<QString, QString>::const_iterator ii = cfgmap.constBegin();
while (ii != cfgmap.constEnd()) {
qDebug() << ii.key() << " " << ii.value();
gout << ii.key() << " " << ii.value() << "\n";
++ii;
}
file.close();
}
else
{
// we have a problem, config file was not opened
qDebug() << "Could not open config file!. Try again.";
return;
}
}
main(int argc, char **argv) {
giant p = newgiant(CM_SHORTS);
giant u = newgiant(CM_SHORTS);
giant v = newgiant(CM_SHORTS);
giant g[6];
giant plus_order = newgiant(CM_SHORTS);
giant minus_order = newgiant(CM_SHORTS);
giant a = newgiant(CM_SHORTS);
giant b = newgiant(CM_SHORTS);
int d, dc, olen, k;
init_tools(CM_SHORTS); /* Basic algorithms. */
printf("Give base prime p:\n"); fflush(stdout);
gin(p);
for(dc=0; dc < 6; dc++) g[dc] = newgiant(CM_SHORTS);
for(dc = 0; dc < DCOUNT; dc++) {
d = disc12[dc];
/* Next, seek representation 4N = u^2 + |d| v^2. */
if(cornacchia4(p, d, u, v) == 0) continue;
/* Here, (u,v) give the quadratic representation of 4p. */
printf("D: %d\n", d); fflush(stdout);
gtog(u, g[0]);
switch(d) {
case -3: olen = 3; /* Six orders: p + 1 +- g[0,1,2]. */
gtog(u, g[1]); gtog(v, g[2]);
addg(g[2], g[2]); addg(v, g[2]); /* g[2] := 3v. */
addg(g[2], g[1]); gshiftright(1, g[1]); /* g[1] = (u + 3v)/2. */
subg(u, g[2]); gshiftright(1, g[2]); absg(g[2]); /* g[2] = |u-3v|/2. */
break;
case -4: olen = 2; /* Four orders: p + 1 +- g[0,1]. */
gtog(v, g[1]); addg(g[1], g[1]); /* g[1] = 2v. */
break;
default: olen = 1; /* Two orders: p + 1 +- g[0]. */
}
for(k=0; k < olen; k++) {
gtog(p, plus_order); iaddg(1, plus_order);
gtog(p, minus_order); iaddg(1, minus_order);
addg(g[k], plus_order);
subg(g[k], minus_order);
printf("curve orders: \n");
printf("(%d) ", prime_probable(plus_order));
gout(plus_order);
printf("(%d) ", prime_probable(minus_order));
gout(minus_order);
}
}
}
bool open(hmLib::gate& rGate_,const std::string& foma_number){
if(is_open())return true;
pGate=&rGate_;
hmLib::ogatestream gout(*pGate);
/*相手の電話番号へ発信*/
gout<<"ATD"<<foma_number<<static_cast<unsigned char>(0x0d)<<static_cast<unsigned char>(0x0a);
return false;
}
bool close(){
if(!is_open())return true;
hmLib::gatestream gout(*pGate);
Sleep(1000);
gout<<"+++"<<static_cast<unsigned char>(0x0d)<<static_cast<unsigned char>(0x0a);
Sleep(1000);
gout<<"ATH"<<static_cast<unsigned char>(0x0d)<<static_cast<unsigned char>(0x0a);
pGate=0;
return false;
}
void
main(
void
)
{
giant x = newgiant(INFINITY), y = newgiant(INFINITY),
p = newgiant(INFINITY), r = newgiant(100);
int j;
printf("Give two integers x, y on separate lines:\n");
gin(x);
gin(y);
gtog(y, p); /* p := y */
mulg(x, p);
printf("y * x = ");
gout(p);
gtog(y, p);
subg(x, p);
printf("y - x = ");
gout(p);
gtog(y, p);
addg(x, p);
printf("y + x = ");
gout(p);
gtog(y, p);
divg(x, p);
printf("y div x = ");
gout(p);
gtog(y, p);
modg(x, p);
printf("y mod x = ");
gout(p);
gtog(y, p);
gcdg(x, p);
printf("GCD(x, y) = ");
gout(p);
/* Next, test which of x, y is greater. */
if (gcompg(x, y) < 0 )
printf("y is greater\n");
else if (gcompg(x,y) == 0)
printf("x, y equal\n");
else
printf("x is greater\n");
/* Next, we see how a giant struct is comprised.
* We make a random, bipolar number of about 100
* digits in base 65536.
*/
for (j=0; j < 100; j++)
{ /* Fill 100 digits randomly. */
r->n[j] = (unsigned short)rand();
}
r->sign = 100 * (1 - 2*(rand()%2));
/* Next, don't forget to check for leading zero digits,
* even though such are unlikely.
*/
j = abs(r->sign) - 1;
while ((r->n[j] == 0) && (j > 0))
{
--j;
}
r->sign = (j+1) * ((r->sign > 0) ? 1: -1);
printf("The random number: "); gout(r);
/* Next, compare a large-FFT multiply with a standard,
* grammar-school multiply.
*/
itog(1, x);
gshiftleft(65536, x);
iaddg(1, x);
itog(5, y);
gshiftleft(30000, y);
itog(1, p);
subg(p, y);
/* Now we multiply (2^65536 + 1)*(5*(2^30000) - 1). */
gtog(y, p);
mulg(x, p); /* Actually invokes FFT method because
bit lengths of x, y are sufficiently large. */
printf("High digit of (2^65536 + 1)*(5*(2^30000) - 1) via FFT mul: %d\n", (int) p->n[abs(p->sign)-1]);
fflush(stdout);
gtog(y, p);
grammarmulg(x, p); /* Grammar-school method. */
printf("High digit via grammar-school mul: %d\n", (int) p->n[abs(p->sign)-1]);
fflush(stdout);
/* Next, perform Fermat test for pseudoprimality. */
printf("Give prime candidate p:\n");
gin(p);
gtog(p, y);
itog(1, x); subg(x, y);
itog(2, x);
powermodg(x, y, p);
if (isone(x))
printf("p is probably prime.\n");
else
printf("p is composite.\n");
}
void adajoint_chr(char **R_file_prefix, int *R_method,
int *R_nperm, int *R_seed,
int *R_nthread, int *R_nsnp, int *R_ngene,
double *R_vU, double *R_score0, double *R_vV,
int *R_vgene_idx, int *R_gene_start, int *R_gene_end,
int *R_vgene_cutpoint,
int *R_gene_cutpoint_start, int *R_gene_cutpoint_end,
double *R_gene_pval, int *R_arr_rank,
int *R_sel_id, int *R_marg_id){
int len_file_prefix = strlen(*R_file_prefix);
char *file_prefix = new char[len_file_prefix + 1];
file_prefix[0] = '\0';
strcat(file_prefix, *R_file_prefix);
int method = *R_method;
assert(method == 1 || method == 2);
int nperm = *R_nperm;
int seed = *R_seed;
int nthread = *R_nthread;
int nsnp = *R_nsnp;
int ngene = *R_ngene;
fvec score0;
fmat V;
fmat U;
load_score0(R_score0, score0, nsnp);
load_cov(R_vV, V, nsnp);
load_U(R_vU, U, nsnp);
imat gene_idx; // index of SNPs in a gene
load_gene_idx(R_vgene_idx, R_gene_start, R_gene_end,
gene_idx, ngene);
imat cutpoint;
load_gene_cutpoint(R_vgene_cutpoint, R_gene_cutpoint_start, R_gene_cutpoint_end,
cutpoint, ngene);
string fprefix (file_prefix);
svec gene_out (ngene, fprefix);
for(int g = 0; g < ngene; ++g){
ostringstream gid;
gid << g;
gene_out[g] = gene_out[g] + string("GID.") + gid.str() + string(".bin");
}
// write obs statistics for all genes
imat sel_id(ngene);
ivec marg_id(ngene);
for(int g = 0; g < ngene; ++g){
fstream gout(gene_out[g].c_str(), ios::out | ios::binary);
if(!gout){
error("Fail to write observed statistics to file");
}
fvec S;
fmat Sigma;
extract_score(S, score0, gene_idx[g]);
extract_cov(Sigma, V, gene_idx[g]);
fvec s;
int ncp = cutpoint[g].size();
int mc = cutpoint[g][ncp - 1];
if(method == 1){
search1(s, sel_id[g], marg_id[g], S, Sigma, mc);
}else{//assert(method == 2)
search2(s, sel_id[g], marg_id[g], S, Sigma, mc);
}
for(int k = 0; k < ncp; ++k){
float u = s[cutpoint[g][k]];
gout.write((char*)(&u), sizeof(u));
}
gout.close();
}
int i_sel_id = -1;
for(int g = 0; g < ngene; ++g){
R_marg_id[g] = gene_idx[g][marg_id[g]] + 1;
for(int k = 0; k < sel_id[g].size(); ++k){
++i_sel_id;
R_sel_id[i_sel_id] = gene_idx[g][sel_id[g][k]] + 1;
}
int nn = gene_idx[g].size() - sel_id[g].size();
while(nn){
++i_sel_id;
R_sel_id[i_sel_id] = -1;
--nn;
}
}
int ngap = min(10000, nperm);
int nblock = nperm / ngap;
for(int b = 0; b < nblock; ++b){
fmat null(ngap, fvec (nsnp, .0f));
drand48_data buf;
// compute null score
#pragma omp parallel num_threads(nthread) private(buf)
{
srand48_r(seed + b * nthread + omp_get_thread_num(), &buf);
#pragma omp for
for(int i = 0; i < ngap; ++i){
fvec rn;
rnorm(buf, nsnp, rn);
for(int j = 0; j < nsnp; ++j){
null[i][j] = .0f;
for(int k = 0; k < nsnp; ++k){
null[i][j] += rn[k] * U[k][j];
}
}
}
}
// write null statistics to local files (per gene)
#pragma omp parallel num_threads(min(nthread, ngene))
{
#pragma omp for
for(int g = 0; g < ngene; ++g){
ofstream gout;
gout.open(gene_out[g].c_str(), ios::out | ios::binary | ios::app);
if(!gout){
error("Fail to write null statistics to file");
}
fmat Sigma;
extract_cov(Sigma, V, gene_idx[g]);
int ns = gene_idx[g].size();
int ncp = cutpoint[g].size();
int mc = cutpoint[g][ncp - 1];
for(int i = 0; i < ngap; ++i){
fvec S;
extract_score(S, null[i], gene_idx[g]);
fvec s;
ivec sel_id;
int marg_id;
if(method == 1){
search1(s, sel_id, marg_id, S, Sigma, mc);
}else{
search2(s, sel_id, marg_id, S, Sigma, mc);
}
for(int k = 0; k < ncp; ++k){
float u = s[cutpoint[g][k]];
gout.write((char*)(&u), sizeof(u));
}
}
gout.close();
}
}
//fmat().swap(null);
}
// read null statistics (per gene)
int irk = -1;
for(int g = 0; g < ngene; ++g){
int ncp = cutpoint[g].size();
vector<VecStat> stat(ncp, VecStat (nperm + 1, STAT0));
fstream gin(gene_out[g].c_str(), ios::in | ios::binary);
for(int i = 0; i < nperm + 1; ++i){
for(int j = 0; j < ncp; ++j){
float s = .0f;
gin.read((char*)(&s), sizeof(s));
stat[j][i].stat = s;
stat[j][i].id = i;
}
}
gin.close();
if(remove(gene_out[g].c_str())){
error("Cannot delete gene output file");
}
imat arr_rank(ncp, ivec (nperm + 1, 0));
#pragma omp parallel num_threads(min(ncp, nthread))
{
#pragma omp for
for(int j = 0; j < ncp; ++j){
sort(stat[j].begin(), stat[j].end(), descending);
for(int i = 0; i < nperm + 1; ++i){
int id = stat[j][i].id;
arr_rank[j][id] = i;
}
}
}
vector<VecStat>().swap(stat);
ivec gene_min_p (nperm + 1, -1);
ivec subsum(nthread, 0);
ivec subtie(nthread, 0);
int m = nperm + 1;
for(int j = 0; j < ncp; ++j){
++irk;
R_arr_rank[irk] = arr_rank[j][0];
if(arr_rank[j][0] < m){
m = arr_rank[j][0];
}
}
gene_min_p[0] = m;
#pragma omp parallel num_threads(nthread)
{
#pragma omp for
for(int i = 1; i < nperm + 1; ++i){
int tid = omp_get_thread_num();
int m = nperm + 1;
for(int j = 0; j < ncp; ++j){
if(arr_rank[j][i] < m){
m = arr_rank[j][i];
}
}
gene_min_p[i] = m;
if(gene_min_p[i] < gene_min_p[0]){
subsum[tid] += 1;
}else if(gene_min_p[i] == gene_min_p[0]){
subtie[tid] += 1;
}else{
;
}
}
}
R_gene_pval[g] = 1.0;
int rep = 0;
for(int t = 0; t < nthread; ++t){
R_gene_pval[g] += subsum[t];
rep += subtie[t];
}
R_gene_pval[g] += rep / 2.0;
R_gene_pval[g] /= nperm + 1;
fstream gout(gene_out[g].c_str(), ios::out | ios::binary);
if(!gout){
error("Fail to write gene statistics to file");
}
for(int i = 0; i < nperm + 1; ++i){
gout.write((char*)(&(gene_min_p[i])), sizeof(gene_min_p[i]));
}
gout.close();
}
delete[] file_prefix;
}
void artp3_chr(char **R_file_prefix, int *R_method,
int *R_nperm, int *R_seed,
int *R_nthread, int *R_nsnp, int *R_ngene,
double *R_vU, double *R_score0, double *R_vV,
int *R_vgene_idx, int *R_gene_start, int *R_gene_end,
int *R_vgene_cutpoint,
int *R_gene_cutpoint_start, int *R_gene_cutpoint_end,
double *R_gene_pval, int *R_arr_rank,
int *R_sel_id, int *R_marg_id){
int len_file_prefix = strlen(*R_file_prefix);
char *file_prefix = new char[len_file_prefix + 1];
file_prefix[0] = '\0';
strcat(file_prefix, *R_file_prefix);
int method = *R_method;
assert(method == 3);
if(method == 3){
;
}
int nperm = *R_nperm;
int seed = *R_seed;
int nthread = *R_nthread;
int nsnp = *R_nsnp;
int ngene = *R_ngene;
assert(nthread == 1);
fvec score0;
fvec sigma2;
fmat U;
fmat V;
load_score0(R_score0, score0, nsnp);
load_cov(R_vV, V, nsnp);
load_sigma2(V, sigma2);
load_U(R_vU, U, nsnp);
imat gene_idx; // index of SNPs in a gene
load_gene_idx(R_vgene_idx, R_gene_start, R_gene_end,
gene_idx, ngene);
imat cutpoint;
load_gene_cutpoint(R_vgene_cutpoint, R_gene_cutpoint_start, R_gene_cutpoint_end,
cutpoint, ngene);
string fprefix (file_prefix);
svec gene_out (ngene, fprefix);
for(int g = 0; g < ngene; ++g){
ostringstream gid;
gid << g;
gene_out[g] = gene_out[g] + string("GID.") + gid.str() + string(".bin");
}
// write obs statistics for all genes
imat sel_id(ngene);
ivec marg_id(ngene);
for(int g = 0; g < ngene; ++g){
fstream gout(gene_out[g].c_str(), ios::out | ios::binary);
if(!gout){
error("Fail to write observed statistics to file");
}
int ns = gene_idx[g].size();
int ncp = cutpoint[g].size();
int max_cutpoint = cutpoint[g][ncp - 1];
fvec s (ns, .0f);
VecStat vs (ns, STAT0);
for(int j = 0; j < ns; ++j){
s[j] = score0[gene_idx[g][j]];
s[j] = pchisq(s[j] * s[j] / sigma2[gene_idx[g][j]], 1, false, true);
vs[j].stat = -s[j];
vs[j].id = j;
}
sort(vs.begin(), vs.end(), descending);
marg_id[g] = vs[0].id;
for(int j = 0; j < ns; ++j){
sel_id[g].push_back(vs[j].id);
}
sort(s.begin(), s.end());
for(int j = 1; j <= max_cutpoint; ++j){
s[j] += s[j - 1];
}
for(int k = 0; k < ncp; ++k){
float u = -s[cutpoint[g][k]];
gout.write((char*)(&u), sizeof(u));
}
gout.close();
}
int i_sel_id = -1;
for(int g = 0; g < ngene; ++g){
R_marg_id[g] = gene_idx[g][marg_id[g]] + 1;
for(int k = 0; k < sel_id[g].size(); ++k){
++i_sel_id;
R_sel_id[i_sel_id] = gene_idx[g][sel_id[g][k]] + 1;
}
int nn = gene_idx[g].size() - sel_id[g].size();
while(nn){
++i_sel_id;
R_sel_id[i_sel_id] = -1;
--nn;
}
}
int ngap = min(10000, nperm);
int nblock = nperm / ngap;
srand(seed);
for(int b = 0; b < nblock; ++b){
fmat null(ngap, fvec (nsnp, .0f));
// compute null statistics
for(int i = 0; i < ngap; ++i){
fvec rn;
rnorm(nsnp, rn);
for(int j = 0; j < nsnp; ++j){
null[i][j] = .0f;
for(int k = 0; k < nsnp; ++k){
null[i][j] += rn[k] * U[k][j];
}
null[i][j] = null[i][j] * null[i][j] / sigma2[j];
null[i][j] = pchisq(null[i][j], 1, false, true);
}
}
// write null statistics to local files (per gene)
for(int g = 0; g < ngene; ++g){
ofstream gout;
gout.open(gene_out[g].c_str(), ios::out | ios::binary | ios::app);
if(!gout){
error("Fail to write null statistics to file");
}
int ns = gene_idx[g].size();
int ncp = cutpoint[g].size();
int max_cutpoint = cutpoint[g][ncp - 1];
for(int i = 0; i < ngap; ++i){
fvec s(ns, .0f);
for(int j = 0; j < ns; ++j){
s[j] = null[i][gene_idx[g][j]];
}
sort(s.begin(), s.end());
for(int j = 1; j <= max_cutpoint; ++j){
s[j] += s[j - 1];
}
for(int k = 0; k < ncp; ++k){
float u = -s[cutpoint[g][k]];
gout.write((char*)(&u), sizeof(u));
}
}
gout.close();
}
//fmat().swap(null);
}
// read null statistics (per gene)
int irk = -1;
for(int g = 0; g < ngene; ++g){
int ncp = cutpoint[g].size();
vector<VecStat> stat(ncp, VecStat (nperm + 1, STAT0));
fstream gin(gene_out[g].c_str(), ios::in | ios::binary);
for(int i = 0; i < nperm + 1; ++i){
for(int j = 0; j < ncp; ++j){
float s = .0f;
gin.read((char*)(&s), sizeof(s));
stat[j][i].stat = s;
stat[j][i].id = i;
}
}
gin.close();
if(remove(gene_out[g].c_str())){
error("Cannot delete gene output file");
}
imat arr_rank(ncp, ivec (nperm + 1, 0));
for(int j = 0; j < ncp; ++j){
sort(stat[j].begin(), stat[j].end(), descending);
for(int i = 0; i < nperm + 1; ++i){
int id = stat[j][i].id;
arr_rank[j][id] = i;
}
}
vector<VecStat>().swap(stat);
ivec gene_min_p (nperm + 1, -1);
ivec subsum(nthread, 0);
ivec subtie(nthread, 0);
int m = nperm + 1;
for(int j = 0; j < ncp; ++j){
++irk;
R_arr_rank[irk] = arr_rank[j][0];
if(arr_rank[j][0] < m){
m = arr_rank[j][0];
}
}
gene_min_p[0] = m;
for(int i = 1; i < nperm + 1; ++i){
int tid = 0;
int m = nperm + 1;
for(int j = 0; j < ncp; ++j){
if(arr_rank[j][i] < m){
m = arr_rank[j][i];
}
}
gene_min_p[i] = m;
if(gene_min_p[i] < gene_min_p[0]){
subsum[tid] += 1;
}else if(gene_min_p[i] == gene_min_p[0]){
subtie[tid] += 1;
}else{
;
}
}
R_gene_pval[g] = 1.0;
int rep = 0;
for(int t = 0; t < nthread; ++t){
R_gene_pval[g] += subsum[t];
rep += subtie[t];
}
R_gene_pval[g] += rep / 2.0;
R_gene_pval[g] /= nperm + 1;
fstream gout(gene_out[g].c_str(), ios::out | ios::binary);
if(!gout){
error("Fail to write gene statistics to file");
}
for(int i = 0; i < nperm + 1; ++i){
gout.write((char*)(&(gene_min_p[i])), sizeof(gene_min_p[i]));
}
gout.close();
}
delete[] file_prefix;
}
bool
tUserGroup( LibTest & tester )
{
gid_t gid = getgid();
gid_t egid = getegid();
gid_t bgid;
struct group grp;
struct group egrp;
struct group bgrp;
char name[50];
char ename[50];
char bname[50];
struct group * tgrp;
tgrp = getgrgid( gid );
strcpy( name, tgrp->gr_name );
memcpy( &grp, tgrp, sizeof( grp ) );
grp.gr_name = name;
tgrp = getgrgid( egid );
strcpy( ename, tgrp->gr_name );
memcpy( &egrp, tgrp, sizeof( egrp ) );
egrp.gr_name = ename;
tgrp = getgrnam( "bin" );
TEST( tgrp != 0 );
strcpy( bname, tgrp->gr_name );
memcpy( &bgrp, tgrp, sizeof( bgrp ) );
bgrp.gr_name = bname;
bgid = bgrp.gr_gid;
size_t bMembCount = 0;
for( size_t m = 0; tgrp->gr_mem[m]; m++ )
bMembCount++;
{
// UserGroup( void )
// getGID( void ) const
// getName( void ) const
// getMembers( void ) const
UserGroup t;
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0 );
TEST( t.getMembers().size() == 0 );
}
{
// UserGroup( bool )
UserGroup t( true );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0 );
TEST( t.getMembers().size() != 0 );
}
{
// UserGroup( gid_t )
UserGroup t( bgid );
TEST( t.getGID() == bgid );
TEST( compare( t.getName(), bgrp.gr_name ) == 0 );
TEST( t.getMembers().size() == 0 );
}
{
// UserGroup( gid_t, bool )
UserGroup t( gid, true );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0 );
TEST( t.getMembers().size() != 0 );
}
{
// UserGroup( const char * )
UserGroup t( bgrp.gr_name );
TEST( t.getGID() == bgid );
TEST( compare( t.getName(), bgrp.gr_name ) == 0 );
TEST( t.getMembers().size() == 0 );
}
{
// UserGroup( const char *, bool )
UserGroup t( grp.gr_name, true );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0);
TEST( t.getMembers().size() != 0 );
}
{
// UserGroup( struct group * )
UserGroup t( getgrgid( gid ) );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0);
TEST( t.getMembers().size() == 0 );
}
{
// UserGroup( struct group *, bool )
UserGroup t( getgrgid( gid ), true );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0);
TEST( t.getMembers().size() != 0 );
}
{
// UserGroup( istream & )
strstream tStream;
UserGroup gout( gid );
gout.write( tStream );
UserGroup t( tStream );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0);
TEST( t.getMembers().size() == 0 );
}
{
// UserGroup( istream &, bool )
strstream tStream;
UserGroup gout( gid );
tStream << gout;
UserGroup t( tStream, true );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0);
TEST( t.getMembers().size() == 0 );
}
{
// UserGroup( istream &, bool, bool )
strstream tStream;
UserGroup gout( gid );
tStream << gout;
UserGroup t( tStream, true, true );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0);
TEST( t.getMembers().size() != 0 );
}
{
// effective( void )
TEST( UserGroup::effective().getGID() == egid );
}
{
// findMembers( void )
// getMembers( void ) const
// isMember( const User & )
UserGroup t( gid );
TEST( t.findMembers() > 0 );
struct group * gent = getgrgid( gid );
struct group g;
g.gr_name = strdup( gent->gr_name );
size_t mCount = 0;
{
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
// use getpwnam to see if user really exists
if(getpwnam(gent->gr_mem[m]) != NULL)
{
mCount++;
}
}
}
g.gr_mem = (char **)malloc( (sizeof( char * ) * mCount) + 1 );
{
size_t n = 0;
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
// use getpwnam to see if user really exists
if(getpwnam(gent->gr_mem[m]) != NULL)
{
g.gr_mem[n++] = strdup( gent->gr_mem[m] );
}
}
g.gr_mem[mCount] = 0;
}
TEST( t.getMembers().size() >= mCount );
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
const User u( g.gr_mem[m] );
TEST( t.isMember( u ) );
}
}
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
free( g.gr_mem[m] );
}
free( g.gr_mem );
free( g.gr_name );
}
}
{
// isMember( const User & ) const
const UserGroup t( gid, true );
struct group * gent = getgrgid( gid );
struct group g;
g.gr_name = strdup( gent->gr_name );
size_t mCount = 0;
{
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
if(getpwnam(gent->gr_mem[m]) != NULL)
{
mCount++;
}
}
}
g.gr_mem = (char **)malloc( (sizeof( char * ) * mCount) + 1 );
{
size_t n = 0;
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
// use getpwnam to see if user really exists
if(getpwnam(gent->gr_mem[m]) != NULL)
{
g.gr_mem[n++] = strdup( gent->gr_mem[m] );
}
}
g.gr_mem[mCount] = 0;
}
TEST( t.getMembers().size() >= mCount );
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
const User u( g.gr_mem[m] );
TEST( t.isMember( u ) );
}
}
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
free( g.gr_mem[m] );
}
free( g.gr_mem );
free( g.gr_name );
}
}
{
// isMember( uid_t )
UserGroup t( gid );
TEST( t.findMembers() > 0 );
struct group * gent = getgrgid( gid );
struct group g;
g.gr_name = strdup( gent->gr_name );
size_t mCount = 0;
{
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
if(getpwnam(gent->gr_mem[m]) != NULL)
{
mCount++;
}
}
}
g.gr_mem = (char **)malloc( (sizeof( char * ) * mCount) + 1 );
{
size_t n = 0;
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
// use getpwnam to see if user really exists
if(getpwnam(gent->gr_mem[m]) != NULL)
{
g.gr_mem[n++] = strdup( gent->gr_mem[m] );
}
}
g.gr_mem[mCount] = 0;
}
TEST( t.getMembers().size() >= mCount );
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
const User u( g.gr_mem[m] );
TEST( t.isMember( u.getUID() ) );
}
}
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
free( g.gr_mem[m] );
}
free( g.gr_mem );
free( g.gr_name );
}
}
{
// isMember( uid_t ) const
const UserGroup t( gid, true );
struct group * gent = getgrgid( gid );
struct group g;
g.gr_name = strdup( gent->gr_name );
size_t mCount = 0;
{
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
if(getpwnam(gent->gr_mem[m]) != NULL)
{
mCount++;
}
}
}
g.gr_mem = (char **)malloc( (sizeof( char * ) * mCount) + 1 );
{
size_t n = 0;
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
// use getpwnam to see if user really exists
if(getpwnam(gent->gr_mem[m]) != NULL)
{
g.gr_mem[n++] = strdup( gent->gr_mem[m] );
}
}
g.gr_mem[mCount] = 0;
}
TEST( t.getMembers().size() >= mCount );
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
const User u( g.gr_mem[m] );
TEST( t.isMember( u.getUID() ) );
}
}
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
free( g.gr_mem[m] );
}
free( g.gr_mem );
free( g.gr_name );
}
}
{
// isMember( const char * )
UserGroup t( gid );
TEST( t.findMembers() > 0 );
struct group * gent = getgrgid( gid );
struct group g;
g.gr_name = strdup( gent->gr_name );
size_t mCount = 0;
{
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
if(getpwnam(gent->gr_mem[m]) != NULL)
{
mCount++;
}
}
}
g.gr_mem = (char **)malloc( (sizeof( char * ) * mCount) + 1 );
{
size_t n = 0;
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
// use getpwnam to see if user really exists
if(getpwnam(gent->gr_mem[m]) != NULL)
{
g.gr_mem[n++] = strdup( gent->gr_mem[m] );
}
}
g.gr_mem[mCount] = 0;
}
TEST( t.getMembers().size() >= mCount );
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
TEST( t.isMember( g.gr_mem[m] ) );
}
}
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
free( g.gr_mem[m] );
}
free( g.gr_mem );
free( g.gr_name );
}
}
{
// isMember( const char * ) const
const UserGroup t( gid, true );
struct group * gent = getgrgid( gid );
struct group g;
g.gr_name = strdup( gent->gr_name );
size_t mCount = 0;
{
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
if(getpwnam(gent->gr_mem[m]) != NULL)
{
mCount++;
}
}
}
g.gr_mem = (char **)malloc( (sizeof( char * ) * mCount) + 1 );
{
size_t n = 0;
for( size_t m = 0; gent->gr_mem[m]; m++ )
{
// use getpwnam to see if user really exists
if(getpwnam(gent->gr_mem[m]) != NULL)
{
g.gr_mem[n++] = strdup( gent->gr_mem[m] );
}
}
g.gr_mem[mCount] = 0;
}
TEST( t.getMembers().size() >= mCount );
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
TEST( t.isMember( g.gr_mem[m] ) );
}
}
{
for( size_t m = 0; g.gr_mem[m]; m++ )
{
free( g.gr_mem[m] );
}
free( g.gr_mem );
free( g.gr_name );
}
}
{
// set( gid_t )
UserGroup t;
t.set( bgid );
TEST( t.getGID() == bgid );
TEST( compare( t.getName(), bgrp.gr_name ) == 0 );
TEST( t.getMembers().size() == 0 );
}
{
// set( gid_t, bool )
UserGroup t( bgid );
t.set( gid, true );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0 );
TEST( t.getMembers().size() != 0 );
}
{
// set( const char * )
UserGroup t( bgid );
t.set( grp.gr_name );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0 );
TEST( t.getMembers().size() == 0 );
}
{
// set( const char *, bool )
UserGroup t( bgid );
t.set( grp.gr_name, true );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0 );
TEST( t.getMembers().size() != 0 );
}
{
// set( const struct group * )
UserGroup t( bgid );
t.set( &grp );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0 );
TEST( t.getMembers().size() == 0 );
}
{
// set( const struct group *, bool )
UserGroup t( bgid );
t.set( &grp, true );
TEST( t.getGID() == gid );
TEST( compare( t.getName(), grp.gr_name ) == 0 );
TEST( t.getMembers().size() != 0 );
}
{
// compare( const UserGroup & ) const
// operator == ( const UserGroup & ) const
// operator < ( const UserGroup & ) const
// operator > ( const UserGroup & ) const
const char * l = 0;
const char * m = 0;
if( compare( grp.gr_name, bgrp.gr_name ) < 0 )
{
l = grp.gr_name;
m = bgrp.gr_name;
}
else
{
l = bgrp.gr_name;
m = grp.gr_name;
}
const UserGroup t( l );
const UserGroup tm( m );
TEST( t.compare( t ) == 0 );
TEST( t == t );
TEST( t.compare( tm ) < 0 );
TEST( t < tm );
TEST( tm.compare( t ) > 0 );
TEST( tm > t );
}
{
// operator const char * ( void ) const
// operator gid_t ( void ) const;
const UserGroup t( gid );
char gn[ 50 ];
strcpy( gn, t );
TEST( compare( t.getName(), gn ) == 0 );
TEST( getgrgid( t )->gr_gid == gid );
}
#if defined( STLUTILS_BINSTREAM )
{
// getBinSize( void ) const
// write( BinStream & dest ) const
// read( BinStream & src )
// BinStream::write( const BinObject & obj )
// BinStream::read( BinObject & obj )
HeapBinStream tStrm;
const UserGroup tw( gid );
UserGroup tr(bgid);
TEST( tw.getBinSize() );
tw.write( tStrm );
tr.read( tStrm );
TEST( tStrm.good() );
TEST( (size_t)tStrm.tellp() == tw.getBinSize() );
TEST( tStrm.tellg() == tStrm.tellp() );
TEST( tr.getBinSize() == tw.getBinSize() );
TEST( tw == tr );
tr = bgid;
TEST( tw != tr );
tStrm.write( tw );
tStrm.read( tr );
TEST( tr == tw );
}
#endif
{
// write( ostream & ) const
// read( istream & )
const UserGroup tw( gid );
UserGroup tr( bgid );
strstream tStrm;
streampos gpos = tStrm.tellg();
streampos ppos = tStrm.tellp();
#ifdef AIX
ppos = 0;
gpos = 0;
#endif
TEST( ppos == 0 );
TEST( gpos == 0 );
tw.write( tStrm );
ppos += (streampos) tw.getBinSize();
TEST( ppos == tStrm.tellp() );
tr.read( tStrm );
gpos += (streampos) tr.getBinSize();
TEST( gpos == tStrm.tellg() );
TEST( tr == tw );
}
{
// toStream( ostream & ) const
// operator << ( ostream &, const FilePath & )
strstream tStrm;
const UserGroup t( gid );
t.toStream( tStrm );
tStrm << t;
}
{
// good( void ) const
// error( void ) const
// getClassName( void ) const
// getVersion( void ) const
// getVersion( bool ) const
const UserGroup t( gid );
TESTR( t.error(), t.good() );
TEST( t.error() != 0 );
TEST( t.getClassName() != 0 );
TEST( t.getVersion() != 0 );
TEST( t.getVersion( false ) != 0 );
}
{
// dumpInfo( ostream & ) const
// version
const UserGroup t( gid );
tester.getDump() << '\n' << t.getClassName() << " toStream:\n";
t.toStream( tester.getDump() );
tester.getDump() << '\n' << t.getClassName() << " dumpInfo:\n";
t.dumpInfo( tester.getDump(), " -> ", true );
tester.getDump() << '\n' << t.getClassName() << " version:\n";
tester.getDump() << t.version;
tester.getDump() << '\n' << tester.getCurrentTestName();
}
{
// ::compare( const UserGroup &, const UserGroup & );
const char * l = 0;
const char * m = 0;
if( compare( grp.gr_name, bgrp.gr_name ) < 0 )
{
l = grp.gr_name;
m = bgrp.gr_name;
}
else
{
l = bgrp.gr_name;
m = grp.gr_name;
}
const UserGroup t( l );
const UserGroup tm( m );
TEST( compare( t, t ) == 0 );
TEST( compare( t, tm ) < 0 );
TEST( compare( tm, t ) > 0 );
}
return( true );
}
static void output(struct termios *sp, int flags)
{
const Tty_t *tp;
struct termios tty;
register int delim = ' ';
register int i,off,off2;
char schar[2];
unsigned int ispeed = cfgetispeed(sp);
unsigned int ospeed = cfgetospeed(sp);
if(flags&G_FLAG)
{
gout(sp);
return;
}
tty = *sp;
sane(&tty);
for(i=0; i < elementsof(Ttable); i++)
{
tp= &Ttable[i];
if(tp->flags&IG)
{
if(tp->flags&NL)
sfputc(sfstdout,'\n');
continue;
}
switch(tp->type)
{
case BIT:
case BITS:
off = off2 = 1;
switch(tp->field)
{
case C_FLAG:
if(sp->c_cflag&tp->mask)
off = 0;
if(tty.c_cflag&tp->mask)
off2 = 0;
break;
case I_FLAG:
if(sp->c_iflag&tp->mask)
off = 0;
if(tty.c_iflag&tp->mask)
off2 = 0;
break;
case O_FLAG:
if((sp->c_oflag&tp->mask)==tp->val)
off = 0;
if(tty.c_oflag&tp->mask)
off2 = 0;
break;
case L_FLAG:
if(sp->c_lflag&tp->mask)
off = 0;
if(tty.c_lflag&tp->mask)
off2 = 0;
}
if(tp->flags&NL)
delim = '\n';
if(!flags && off==off2)
continue;
if(!off)
sfprintf(sfstdout,"%s%c",tp->name,delim);
else if(tp->type==BIT)
sfprintf(sfstdout,"-%s%c",tp->name,delim);
delim = ' ';
break;
case CHAR:
off = sp->c_cc[tp->mask];
if(tp->flags&NL)
delim = '\n';
if(!flags && off==(unsigned char)tty.c_cc[tp->mask])
continue;
if(off==_POSIX_VDISABLE)
sfprintf(sfstdout,"%s = <undef>;%c",tp->name,delim);
else if(isprint(off&0xff))
sfprintf(sfstdout,"%s = %c;%c",tp->name,off,delim);
else
#if CC_NATIVE == CC_ASCII
sfprintf(sfstdout,"%s = ^%c;%c",tp->name,off==0177?'?':(off^0100),delim);
#else
{
off = ccmapc(off, CC_NATIVE, CC_ASCII);
sfprintf(sfstdout,"%s = ^%c;%c",tp->name,off==0177?'?':ccmapc(off^0100,CC_ASCII,CC_NATIVE),delim);
}
#endif
delim = ' ';
break;
case SIZE:
if((sp->c_cflag&CSIZE)!=tp->mask)
continue;
if(flags || (sp->c_cflag&CSIZE) != (tty.c_cflag&CSIZE))
sfprintf(sfstdout,"%s ",tp->name);
break;
case SPEED:
if(tp->mask==ispeed)
{
if(ispeed!=ospeed)
schar[0]='i';
else
schar[0]=0;
}
else if(tp->mask==ospeed)
schar[0]='o';
else
continue;
schar[1] = 0;
#ifdef TIOCSWINSZ
{
struct winsize win;
off = ioctl(0,TIOCGWINSZ,&win);
if(off>=0)
sfprintf(sfstdout,"%sspeed %s baud; rows %d; columns %d;\n",schar,tp->name,win.ws_row,win.ws_col);
}
if(off<0)
#endif
sfprintf(sfstdout,"%sspeed %s baud;\n",schar,tp->name);
}
}
if(delim=='\n')
sfputc(sfstdout,'\n');
}
