/*------------------------------------------------------------------------- * Function: test_write_bad * * Purpose: Try writing to an existing data but using an incompatible * size or data type. * * Return: Success: 0 * * Failure: number of errors. * * Programmer: Robb Matzke * Tuesday, February 9, 1999 * * Modifications: * Robb Matzke, 2000-01-12 * Changed hyphens to underscores in object names because silo * now fails when underscores are present in the name. *------------------------------------------------------------------------- */ static int test_write_bad(DBfile *dbfile) { int i, data[TEST_NELMTS], dims[4], nerrors=0; #ifdef HAVE_HDF5_H H5E_BEGIN_TRY { #endif puts("=== Error conditions ==="); for (i=0; i<TEST_NELMTS; i++) data[i] = 911; /* Write to "3d_int" but supply only 1 dimension */ dims[0] = TEST_NELMTS; if (DBWrite(dbfile, "3d_int", data, dims, 1, DB_INT)>=0) { puts("DBWrite() to 3d_int with 1d data should have failed"); nerrors++; } /* Write to "3d_int" but with the wrong sizes */ dims[0] = 3; dims[2] = 4; dims[1] = TEST_NELMTS/(dims[0]*dims[2]); if (DBWrite(dbfile, "3d_int", data, dims, 3, DB_INT)>=0) { puts("DBWrite() to 3d_int with wrong dims should have faild"); nerrors++; } /* Write to "4d_float" but with integer data */ DBForceSingle(TRUE); dims[0] = 6; dims[1] = 5; dims[2] = 4; dims[3] = TEST_NELMTS/(dims[0]*dims[1]*dims[2]); if (DBWrite(dbfile, "4d_float", data, dims, 4, DB_INT)>=0) { puts("DBWrite() to 4d_float with integer data should have failed"); nerrors++; } DBForceSingle(FALSE); #ifdef HAVE_HDF5_H } H5E_END_TRY; #endif return nerrors; }
/*------------------------------------------------------------------------- * Function: main * * Purpose: Test various read operations. * * Return: 0 * * Programmer:Mark C. Miller, Thu Jul 15 08:23:56 PDT 2010 *------------------------------------------------------------------------- */ int main(int argc, char *argv[]) { int driver = DB_PDB, driverType = DB_PDB; int i, err = 0; DBfile *dbfile; int show_all_errors = FALSE; char filename[256]; char *obj_names[13]; int ordering[13]; /* Parse command-line */ for (i=1; i<argc; i++) { if (!strncmp(argv[i], "DB_PDB", 6)) { driver = StringToDriver(argv[i]); driverType = DB_PDB; } else if (!strncmp(argv[i], "DB_HDF5", 7)) { driver = StringToDriver(argv[i]); driverType = DB_HDF5; } else if (!strcmp(argv[i], "show-all-errors")) { show_all_errors = 1; } else if (argv[i][0] != '\0') { fprintf(stderr, "%s: ignored argument `%s'\n", argv[0], argv[i]); } } DBShowErrors(show_all_errors?DB_ALL_AND_DRVR:DB_TOP, NULL); DBForceSingle(1); sprintf(filename, "multi_rect2d.%s", driverType==DB_PDB?"pdb":"h5"); dbfile = DBOpen(filename, DB_UNKNOWN, DB_READ); DBSetDir(dbfile, "block7"); obj_names[0] = "cycle"; obj_names[1] = "d"; obj_names[2] = "../_fileinfo"; obj_names[3] = "otherfile:block7/u"; obj_names[4] = "v"; obj_names[5] = "u"; obj_names[6] = "/.silo/#000005"; obj_names[7] = "../block7/d"; obj_names[8] = "../block9/d"; obj_names[9] = "../block4/d"; obj_names[10] = "../mesh1_hidden"; obj_names[11] = "../mesh1"; obj_names[12] = "../block11/u"; DBSortObjectsByOffset(dbfile, 13, obj_names, ordering); printf("UNsorted objects...\n"); for (i = 0; i < 13; i++) printf("\t\"%s\"\n", obj_names[i]); printf("Sorted objects...\n"); for (i = 0; i < 13; i++) printf("\t\"%s\"\n", obj_names[ordering[i]]); DBClose(dbfile); return err; }
int main(int argc, char *argv[]) { int nerrors = 0; int i, j, ndims=1; int driver=DB_HDF5; char *filename="largefile.h5"; DBfile *dbfile; /* Parse command-line */ for (i=1; i<argc; i++) { if (!strcmp(argv[i], "DB_PDB")) { fprintf(stderr, "This test only supported on HDF5 driver\n"); exit(1); } else if (!strcmp(argv[i], "DB_HDF5")) { driver = DB_HDF5; filename = "largefile.h5"; } else { fprintf(stderr, "%s: ignored argument '%s'\n", argv[0], argv[i]); } } DBShowErrors(DB_TOP, NULL); DBForceSingle(1); /* * Create a file that contains a simple variables. */ printf("Creating file: '%s'\n", filename); dbfile = DBCreate(filename, 0, DB_LOCAL, "Simple Test", driver); for (j = 0; j < 2500; j++) { char tmpname[64]; if (j % 100 == 0) printf("Iterations %04d to %04d of %04d\n", j, j+100-1, 2500); sprintf(tmpname, "simple_%04d", j); for (i = 0; i < dims[0]; i++) val[i] = (float) dims[0] * j + i; if (DBWrite(dbfile, tmpname, val, dims, ndims, DB_FLOAT) != 0) { DBClose(dbfile); exit(1); } } /* * Put some objects VisIt can process at the end of the file */ build_curve(dbfile, driver); DBClose(dbfile); /* * Now try opening the file again and reading the simple * variable. */ printf("Reopening '%s'\n", filename); dbfile = DBOpen(filename, driver, DB_READ); if (dbfile == 0) { printf("Unable to Reopen file for reading\n"); exit(1); } /* * Randomly examine 50 arrays from the first and last 500 */ srand(0xBabeFace); for (j = 0; j < 100; j++) { char tmpname[64]; int n = rand() % 500 + (j >= 50 ? 200 : 0); sprintf(tmpname, "simple_%04d", n); if (DBReadVar(dbfile, tmpname, rval) < 0) { nerrors++; if (nerrors < 10) printf("DBReadVar for \"%s\" failed\n", tmpname); if (nerrors == 10) printf("Further errors will be suppressed\n"); } for (i = 0; i < dims[0]; i++) { val[i] = (float) dims[0] * n + i; if (val[i] != rval[i]) { nerrors++; if (nerrors < 10) printf("Read error in \"%s\" at position %04d. Expected %f, got %f\n", tmpname, i, val[i], rval[i]); if (nerrors == 10) printf("Further errors will be suppressed\n"); break; } } } DBClose(dbfile); exit(nerrors > 0); }
/*---------------------------------------------------------------------------- *---------------------------------------------------------------------------- * Main Program *---------------------------------------------------------------------------- *---------------------------------------------------------------------------- * Modifications: * Robb Matzke, 1999-04-09 * Added argument parsing to control the driver which is used. * *---------------------------------------------------------------------------*/ int main(int argc, char *argv[]) { int x,y; int m,s; int err, mixc; int i, driver=DB_PDB, reorder=0; char filename[64], *file_ext=".pdb"; int show_all_errors = FALSE; DBfile *db; /* Parse command-line */ for (i=1; i<argc; i++) { if (!strncmp(argv[i], "DB_PDB", 6)) { driver = StringToDriver(argv[i]); file_ext = ".pdb"; } else if (!strncmp(argv[i], "DB_HDF5", 7)) { driver = StringToDriver(argv[i]); file_ext = ".h5"; } else if (!strcmp(argv[i], "reorder")) { reorder = 1; } else if (!strcmp(argv[i], "show-all-errors")) { show_all_errors = 1; } else if (!strcmp(argv[i], "difftol")) { difftol = strtod(argv[i+1], 0); i++; } else if (argv[i][0] != '\0') { fprintf(stderr, "%s: ignored argument `%s'\n", argv[0], argv[i]); } } if (show_all_errors) DBShowErrors(DB_ALL_AND_DRVR, 0); Mesh_Create(&mesh,20,20); /* -=-=-=-=-=-=-=-=-=- */ /* Setup Coordinates */ /* -=-=-=-=-=-=-=-=-=- */ printf("Creating the mesh\n"); for (x=0;x<mesh.nx;x++) { for (y=0;y<mesh.ny;y++) { float xx = (x-10); float yy = ((xx-8.5)*xx*(xx+8.5))/40. + (y-10); mesh.node[x][y].x = xx*2+(yy*yy/50 - 3); mesh.node[x][y].y = yy; } } /* -=-=-=-=-=-=-=-=-=- */ /* Do Mesh Variables */ /* -=-=-=-=-=-=-=-=-=- */ printf("Creating the variables\n"); /* do zone vars */ for (x=0;x<mesh.zx;x++) { for (y=0;y<mesh.zy;y++) { mesh.zone[x][y].vars[ZV_P] = sqrt((mesh.node[x][y].x*mesh.node[x][y].x) + (mesh.node[x][y].y*mesh.node[x][y].y)); mesh.zone[x][y].vars[ZV_D] = 10. / (mesh.zone[x][y].vars[ZV_P]+5); } } /* do node vars */ for (x=0;x<mesh.nx;x++) { for (y=0;y<mesh.ny;y++) { mesh.node[x][y].vars[NV_U] = mesh.node[x][y].x; mesh.node[x][y].vars[NV_V] = mesh.node[x][y].y; } } /* -=-=-=-=-=-=-=-=-=- */ /* Do Materials */ /* -=-=-=-=-=-=-=-=-=- */ printf("Overlaying materials\n"); /* initialize */ for (x=0;x<mesh.zx;x++) { for (y=0;y<mesh.zy;y++) { mesh.zone[x][y].nmats=0; } } /* do it */ for (m=1; m<=nmat; m++) { for (x=0;x<mesh.zx;x++) { for (y=0;y<mesh.zy;y++) { float x00=mesh.zone[x][y].n[0][0]->x; float y00=mesh.zone[x][y].n[0][0]->y; float x10=mesh.zone[x][y].n[1][0]->x; float y10=mesh.zone[x][y].n[1][0]->y; float x01=mesh.zone[x][y].n[0][1]->x; float y01=mesh.zone[x][y].n[0][1]->y; float x11=mesh.zone[x][y].n[1][1]->x; float y11=mesh.zone[x][y].n[1][1]->y; int i,j; int c=0; float vf=0.; double vfd=0.; const int RES=40; /* subsampling resolution */ /* Subsample the zone at RESxRES to * * get a more accurate volume fraction */ for (i=0;i<=RES;i++) { for (j=0;j<=RES;j++) { float ii=(float)i/(float)RES; float jj=(float)j/(float)RES; float xc = (x00*ii + x10*(1.-ii))*jj + (x01*ii + x11*(1.-ii))*(1.-jj); float yc = (y00*ii + y10*(1.-ii))*jj + (y01*ii + y11*(1.-ii))*(1.-jj); switch (m) { case 1: if (xc>-15 && yc>2) vf++; break; case 2: if (xc>-15 && yc<=2 && xc-5>yc) vf++; break; case 3: if (xc>-15 && yc<=2 && xc-5<=yc) vf++; break; case 4: if (xc<= -15) vf++; break; default: break; } c++; } } vfd = vf; vf /= (float)c; vfd /= (double)c; mesh.zone[x][y].matvf[m]=vf; mesh.zone[x][y].matvfd[m]=vfd; if (vf) mesh.zone[x][y].nmats++; } } } /* check for errors in mat-assigning code! */ err=0; for (x=0;x<mesh.zx;x++) { for (y=0;y<mesh.zy;y++) { float vf=0; for (m=1; m<=nmat; m++) { vf += mesh.zone[x][y].matvf[m]; } if (vf<.99 || vf>1.01) { printf("Error in zone x=%d y=%d: vf = %f\n",x,y,vf); err++; } } } if (err) exit(err); /* -=-=-=-=-=-=-=-=-=- */ /* do species stuff! */ /* -=-=-=-=-=-=-=-=-=- */ printf("Overlaying material species\n"); err=0; for (m=1;m<=nmat;m++) { for (x=0;x<mesh.zx;x++) { for (y=0;y<mesh.zy;y++) { if (mesh.zone[x][y].matvf[m]>0.) { float mftot=0.; for (s=0; s<nspec[m-1]; s++) { float x00=mesh.zone[x][y].n[0][0]->x; float y00=mesh.zone[x][y].n[0][0]->y; float x10=mesh.zone[x][y].n[1][0]->x; float y10=mesh.zone[x][y].n[1][0]->y; float x01=mesh.zone[x][y].n[0][1]->x; float y01=mesh.zone[x][y].n[0][1]->y; float x11=mesh.zone[x][y].n[1][1]->x; float y11=mesh.zone[x][y].n[1][1]->y; float xx=(x00+x10+x01+x11)/4.; float yy=(y00+y10+y01+y11)/4.; double xxd=(x00+x10+x01+x11)/4.; double yyd=(y00+y10+y01+y11)/4.; float mf=0.; double mfd=0.; float g,g1,g2; /* gradient values */ double gd,g1d,g2d; /* gradient values */ switch (m) { case 1: g=lim01((xx+20.)/40.); gd=lim01((xxd+20.)/40.); switch (s) { case 0: mf=g; mfd=gd; break; case 1: mf=1.-g; mfd=1.-gd; break; default: exit(-1); } break; case 2: g=lim01((yy+20.)/40.); gd=lim01((yyd+20.)/40.); switch (s) { case 0: mf=.2+g/2.; mfd=.2+gd/2.; break; case 1: mf=.5-g/2.; mfd=.5-gd/2.; break; case 2: mf=.2; mfd=.2; break; case 3: mf=.1; mfd=.1; break; default: exit(-1); } break; case 3: g1=lim01((xx-5+yy+40.)/80.); g2=lim01((xx-5-yy+40.)/80.); g1d=lim01((xxd-5+yyd+40.)/80.); g2d=lim01((xxd-5-yyd+40.)/80.); switch (s) { case 0: mf=g1/2.; mfd=g1d/2.; break; case 1: mf=g2/4.; mfd=g2d/4.; break; case 2: mf=.5-g1/2.; mfd=.5-g1d/2.; break; case 3: mf=.25-g2/4.; mfd=.25-g2d/4.; break; case 4: mf=.25; mfd=.25; break; default: exit(-1); } break; case 4: switch (s) { case 0: mf=1.0; mfd=1.0; break; default: exit(-1); } break; default: exit(-1); break; } mesh.zone[x][y].specmf[m][s] = mf; mesh.zone[x][y].specmfd[m][s] = mfd; mftot += mf; } if (mftot < .99 || mftot > 1.01) { printf("Error in zone x=%d y=%d mat=%d: mf = %f\n",x,y,m,mftot); err++; } } } } } if (err) exit(err); /* -=-=-=-=-=-=-=-=-=- */ /* write to silo files */ /* -=-=-=-=-=-=-=-=-=- */ sprintf(filename, "specmix_quad%s", file_ext); printf("Writing %s using curvilinear mesh.\n", filename); db=DBCreate(filename, DB_CLOBBER, DB_LOCAL, "Mixed zone species test", driver); mixc=domatspec(db, doWrite, 0); writemesh_curv2d(db,mixc,reorder); DBClose(db); sprintf(filename, "specmix_ucd%s", file_ext); printf("Writing %s using unstructured mesh.\n", filename); db=DBCreate(filename, DB_CLOBBER, DB_LOCAL, "Mixed zone species test", driver); mixc=domatspec(db, doWrite, 0); writemesh_ucd2d(db,mixc,reorder); DBClose(db); /* Test read-back of species */ printf("Reading %s with Force Single off.\n", filename); db=DBOpen(filename, driver, DB_READ); domatspec(db, doReadAndCheck, 0); DBClose(db); printf("Reading %s with Force Single ON.\n", filename); DBForceSingle(1); db=DBOpen(filename, driver, DB_READ); domatspec(db, doReadAndCheck, 1); DBClose(db); printf("Done!\n"); for (x=0;x<mesh.nx;x++) free(mesh.node[x]); free(mesh.node); for (x=0;x<mesh.zx;x++) free(mesh.zone[x]); free(mesh.zone); CleanupDriverStuff(); return 0; }
/*------------------------------------------------------------------------- * Function: main * * Purpose: * * Return: 0 * * Programmer: * * Modifications: * Robb Matzke, 1999-04-09 * Added argument parsing to control the driver which is used. * * Mark C. Miller, Mon Sep 21 15:20:30 PDT 2009 * Added code to test long long type. * * Mark C. Miller, Wed Sep 23 11:57:24 PDT 2009 * Added logic to test DBInqFile. * * Mark C. Miller, Fri Nov 13 15:40:35 PST 2009 * Test long long on PDB driver too. *------------------------------------------------------------------------- */ int main(int argc, char *argv[]) { int i, j, k; int ndims, dims[3]; float val[NX * NY * NZ]; long long lval[NX * NY * NZ]; int offset[3], length[3], stride[3]; float val2[NX * NY * NZ]; long long *lval2 = 0; int cnt, driver=DB_PDB; char *filename="simple.pdb"; int k1, k2; int err = 0; int inqval; DBfile *dbfile; int show_all_errors = FALSE; /* Parse command-line */ for (i=1; i<argc; i++) { if (!strncmp(argv[i], "DB_PDB", 6)) { driver = StringToDriver(argv[i]); filename = "simple.pdb"; } else if (!strncmp(argv[i], "DB_HDF5", 7)) { driver = StringToDriver(argv[i]); filename = "simple.h5"; } else if (!strcmp(argv[i], "show-all-errors")) { show_all_errors = 1; } else if (argv[i][0] != '\0') { fprintf(stderr, "%s: ignored argument `%s'\n", argv[0], argv[i]); } } DBShowErrors(show_all_errors?DB_ALL_AND_DRVR:DB_TOP, NULL); DBForceSingle(1); /* * Build a simple variables. */ ndims = 3; dims[0] = NZ; dims[1] = NY; dims[2] = NX; for (k = 0; k < NZ; k++) { for (j = 0; j < NY; j++) { for (i = 0; i < NX; i++) { val[i + j * NX + k * NX * NY] = i + j * NX + k * NX * NY; lval[i + j * NX + k * NX * NY] = ((long long) 1 << 35) + i + j * NX + k * NX * NY; } } } /* Test InqFile on a PDB (but not Silo) file */ if (driver == DB_PDB) inqval = DBInqFile("not_a_silo_file.pdb"); else inqval = DBInqFile("not_a_silo_file.h5"); if (inqval < 0) { fprintf(stderr, "Error in InqFile attempting to identify not_a_silo_file"); err = 1; } else if (inqval > 0) { fprintf(stderr, "InqFile incorrectly identified not_a_silo_file"); err = 1; } /* Create empty silo file to test InqFile */ dbfile = DBCreate(filename, 0, DB_LOCAL, "Empty Silo File", driver); DBClose(dbfile); if (DBInqFile(filename) <= 0) { fprintf(stderr, "InqFile says file created via DBCreate is NOT a silo file"); err = 1; } unlink(filename); /* * Create a file that contains a simple variables. */ printf("Creating file: `%s'\n", filename); dbfile = DBCreate(filename, 0, DB_LOCAL, "Simple Test", driver); DBWrite(dbfile, "simple", val, dims, ndims, DB_FLOAT); DBWrite(dbfile, "longlong", lval, dims, ndims, DB_LONG_LONG); DBClose(dbfile); /* * Now try opening the file again and reading the simple * variable. */ printf("Reopening `%s'\n", filename); dbfile = DBOpen(filename, driver, DB_READ); offset[0] = 0; offset[1] = 0; offset[2] = 0; length[0] = NZ2; length[1] = NY2; length[2] = NX2; stride[0] = 1; stride[1] = 1; stride[2] = 1; for (i = 0; i < NX * NY * NZ; i++) val2[i] = 0; DBReadVarSlice(dbfile, "simple", offset, length, stride, ndims, val2); lval2 = DBGetVar(dbfile, "longlong"); DBClose(dbfile); /* * Check the data. */ cnt = 0; for (k = 0; k < NZ2; k++) { for (j = 0; j < NY2; j++) { for (i = 0; i < NX2; i++) { if (val2[i + j * NX2 + k * NX2 * NY2] != val[i + j * NX + k * NX * NY]) cnt++; } } } err += cnt; printf("%d values don't match\n", cnt); cnt = 0; k1 = NX2 * NY2 * NZ2; k2 = NX * NY * NZ; for (i = k1; i < k2; i++) if (val2[i] != 0) cnt++; printf("%d values were overwritten\n", cnt); cnt = 0; for (k = 0; k < NZ && lval2; k++) { for (j = 0; j < NY; j++) { for (i = 0; i < NX; i++) { if (lval2[i + j * NX + k * NX * NY] != lval[i + j * NX + k * NX * NY]) cnt++; } } } err += cnt; printf("%d long long values don't match\n", cnt); if (lval2) free(lval2); CleanupDriverStuff(); return err; }
/*------------------------------------------------------------------------- * Function: test_write_all * * Purpose: Write complete arrays from file to disk with DBWrite(). This * only tests that DBWrite() returns success -- it doesn't * attempt to read the data and compare it to what was written. * * Return: Success: 0 * * Failure: number of errors * * Programmer: Robb Matzke * Tuesday, February 9, 1999 * * Modifications: * Robb Matzke, 2000-01-12 * Changed hyphens to underscores in object names because silo * now fails when underscores are present in the name. *------------------------------------------------------------------------- */ static int test_write_all(DBfile *dbfile) { int i, dims[5], nerrors=0; puts("DBWrite():"); /* Initialize output arrays */ for (i=0; i<TEST_NELMTS; i++, cntr_g++) { cdata_g[i] = cntr_g%128; /*`char' has unknown sign so play it safe*/ sdata_g[i] = cntr_g-TEST_NELMTS/2; idata_g[i] = cntr_g-TEST_NELMTS/2; ldata_g[i] = cntr_g-TEST_NELMTS/2; fdata_g[i] = (cntr_g-TEST_NELMTS/2)/10.0; ddata_g[i] = (cntr_g-TEST_NELMTS/2)/10.0; } /* 1d char */ puts(" 1d_char"); dims[0] = TEST_NELMTS; if (DBWrite(dbfile, "1d_char", cdata_g, dims, 1, DB_CHAR)<0) { puts(" DBWrite() failed"); nerrors++; } /* 2d short */ puts(" 2d_short"); dims[0] = 2; dims[1] = TEST_NELMTS/dims[0]; if (DBWrite(dbfile, "2d_short", sdata_g, dims, 2, DB_SHORT)<0) { puts(" DBWrite() failed"); nerrors++; } /* 3d int */ puts(" 3d_int"); dims[0] = 12; dims[1] = 30; dims[2] = TEST_NELMTS/(dims[0]*dims[1]); if (DBWrite(dbfile, "3d_int", idata_g, dims, 3, DB_INT)<0) { puts(" DBWrite() failed"); nerrors++; } /* 3d long */ puts(" 3d_long"); dims[0] = 5; dims[1] = 6; dims[2] = TEST_NELMTS/(dims[0]*dims[1]); if (DBWrite(dbfile, "3d_long", ldata_g, dims, 3, DB_LONG)<0) { puts(" DBWrite() failed"); nerrors++; } /* 4d float */ DBForceSingle(TRUE); puts(" 4d_float"); dims[0] = 6; dims[1] = 5; dims[2] = 4; dims[3] = TEST_NELMTS/(dims[0]*dims[1]*dims[2]); if (DBWrite(dbfile, "4d_float", fdata_g, dims, 4, DB_FLOAT)<0) { puts(" DBWrite() failed"); nerrors++; } DBForceSingle(FALSE); /* 5d double */ puts(" 5d_double"); dims[0] = 3; dims[1] = 2; dims[2] = 6; dims[3] = 5; dims[4] = TEST_NELMTS/(dims[0]*dims[1]*dims[2]*dims[3]); if (DBWrite(dbfile, "5d_double", ddata_g, dims, 5, DB_DOUBLE)<0) { puts(" DBWrite() failed"); nerrors++; } return nerrors; }
/*------------------------------------------------------------------------- * Function: test_get_all * * Purpose: Tests DBGetVar() by reading each of the variables that were * written by test_write_all() and comparing the results to what * is stored in memory. * * This step is skipped if the architecture is not DB_LOCAL * because the data might be read back as some other type than * what was written. Unfortunately silo doesn't give the caller * any control over how data is read. * * Return: Success: 0 * * Failure: number of errors * * Programmer: Robb Matzke * Tuesday, February 9, 1999 * * Modifications: * Robb Matzke, 2000-01-12 * Changed hyphens to underscores in object names because silo * now fails when underscores are present in the name. *------------------------------------------------------------------------- */ static int test_get_all(DBfile *dbfile) { int i, nerrors=0; char *cdata_in=NULL; short *sdata_in=NULL; int *idata_in=NULL; long *ldata_in=NULL; float *fdata_in=NULL; double *ddata_in=NULL; puts("DBGetVar():"); if (DB_LOCAL!=arch_g) { puts(" Skipped because target is not DB_LOCAL" " -- use browser instead"); return 0; } /* 1d char */ puts(" 1d_char"); if (NULL==(cdata_in=DBGetVar(dbfile, "1d_char"))) { puts(" DBGetVar() failed"); nerrors++; } else { for (i=0; i<TEST_NELMTS; i++) { if (cdata_g[i]!=cdata_in[i]) { printf(" failed at i=%d: out=%d, in=%d\n", i, cdata_g[i], cdata_in[i]); nerrors++; } } free(cdata_in); } /* 2d short */ puts(" 2d_short"); if (NULL==(sdata_in=DBGetVar(dbfile, "2d_short"))) { puts(" DBGetVar() failed"); nerrors++; } else { for (i=0; i<TEST_NELMTS; i++) { if (sdata_g[i]!=sdata_in[i]) { printf(" failed at i=%d: out=%d, in=%d\n", i, sdata_g[i], sdata_in[i]); nerrors++; } } free(sdata_in); } /* 3d int */ puts(" 3d_int"); if (NULL==(idata_in=DBGetVar(dbfile, "3d_int"))) { puts(" DBGetVar() failed"); nerrors++; } else { for (i=0; i<TEST_NELMTS; i++) { if (idata_g[i]!=idata_in[i]) { printf(" failed at i=%d: out=%d, in=%d\n", i, idata_g[i], idata_in[i]); } } free(idata_in); } /* 3d long */ puts(" 3d_long"); if (NULL==(ldata_in=DBGetVar(dbfile, "3d_long"))) { puts(" DBGetVar() failed"); nerrors++; } else { for (i=0; i<TEST_NELMTS; i++) { if (ldata_g[i]!=ldata_in[i]) { printf(" failed at i=%d: out=%ld, in=%ld\n", i, ldata_g[i], ldata_in[i]); } } free(ldata_in); } /* 4d float */ DBForceSingle(TRUE); puts(" 4d_float"); if (NULL==(fdata_in=DBGetVar(dbfile, "4d_float"))) { puts(" DBGetVar() failed"); nerrors++; } else { printf("testing DBGetVar of 4d_float\n"); for (i=0; i<TEST_NELMTS; i++) { if (fdata_g[i]!=fdata_in[i]) { printf(" failed at i=%d: out=%g, in=%g\n", i, fdata_g[i], fdata_in[i]); } } free(fdata_in); } DBForceSingle(FALSE); /* 5d double */ puts(" 5d_double"); if (NULL==(ddata_in=DBGetVar(dbfile, "5d_double"))) { puts(" DBGetVar() failed"); nerrors++; } else { for (i=0; i<TEST_NELMTS; i++) { if (ddata_g[i]!=ddata_in[i]) { printf(" failed at i=%d: out=%g, in=%g\n", i, ddata_g[i], ddata_in[i]); } } free(ddata_in); } return nerrors; }
/*------------------------------------------------------------------------- * Function: test_read_all * * Purpose: Tests DBReadVar() by reading each of the variables that were * written by test_write_all() and comparing the results to what * is stored in memory. * * This step is skipped if the architecture is not DB_LOCAL * because the data might be read back as some other type than * what was written. Unfortunately silo doesn't give the caller * any control over how data is read. * * Return: Success: 0 * * Failure: number of errors * * Programmer: Robb Matzke * Tuesday, February 9, 1999 * * Modifications: * Robb Matzke, 2000-01-12 * Changed hyphens to underscores in object names because silo * now fails when underscores are present in the name. *------------------------------------------------------------------------- */ static int test_read_all(DBfile *dbfile) { int i, nerrors=0; char cdata_in[TEST_NELMTS]; short sdata_in[TEST_NELMTS]; int idata_in[TEST_NELMTS]; long ldata_in[TEST_NELMTS]; float fdata_in[TEST_NELMTS]; double ddata_in[TEST_NELMTS]; puts("DBReadVar():"); if (DB_LOCAL!=arch_g) { puts(" Skipped because target is not DB_LOCAL" " -- use browser instead"); return 0; } /* 1d char */ puts(" 1d_char"); memset(cdata_in, 0xff, sizeof cdata_in); if (DBReadVar(dbfile, "1d_char", cdata_in)<0) { puts(" DBReadVar() failed"); nerrors++; } else { for (i=0; i<TEST_NELMTS; i++) { if (cdata_g[i]!=cdata_in[i]) { printf(" failed at i=%d: out=%d, in=%d\n", i, cdata_g[i], cdata_in[i]); nerrors++; } } } /* 2d short */ puts(" 2d_short"); memset(sdata_in, 0xff, sizeof sdata_in); if (DBReadVar(dbfile, "2d_short", sdata_in)<0) { puts(" DBReadVar() failed"); nerrors++; } else { for (i=0; i<TEST_NELMTS; i++) { if (sdata_g[i]!=sdata_in[i]) { printf(" failed at i=%d: out=%d, in=%d\n", i, sdata_g[i], sdata_in[i]); nerrors++; } } } /* 3d int */ puts(" 3d_int"); memset(idata_in, 0xff, sizeof idata_in); if (DBReadVar(dbfile, "3d_int", idata_in)<0) { puts(" DBReadVar() failed"); nerrors++; } else { for (i=0; i<TEST_NELMTS; i++) { if (idata_g[i]!=idata_in[i]) { printf(" failed at i=%d: out=%d, in=%d\n", i, idata_g[i], idata_in[i]); } } } /* 3d long */ puts(" 3d_long"); memset(ldata_in, 0xff, sizeof ldata_in); if (DBReadVar(dbfile, "3d_long", ldata_in)<0) { puts(" DBReadVar() failed"); nerrors++; } else { for (i=0; i<TEST_NELMTS; i++) { if (ldata_g[i]!=ldata_in[i]) { printf(" failed at i=%d: out=%ld, in=%ld\n", i, ldata_g[i], ldata_in[i]); } } } /* 4d float */ DBForceSingle(TRUE); puts(" 4d_float"); memset(fdata_in, 0xff, sizeof fdata_in); if (DBReadVar(dbfile, "4d_float", fdata_in)<0) { puts(" DBReadVar() failed"); nerrors++; } else { printf("checking read of first 4d_float\n"); for (i=0; i<TEST_NELMTS; i++) { if (fdata_g[i]!=fdata_in[i]) { printf(" failed at i=%d: out=%g, in=%g\n", i, fdata_g[i], fdata_in[i]); } } } DBForceSingle(FALSE); /* 5d double */ puts(" 5d_double"); memset(ddata_in, 0xff, sizeof ddata_in); if (DBReadVar(dbfile, "5d_double", ddata_in)<0) { puts(" DBReadVar() failed"); nerrors++; } else { for (i=0; i<TEST_NELMTS; i++) { if (ddata_g[i]!=ddata_in[i]) { printf(" failed at i=%d: out=%g, in=%g\n", i, ddata_g[i], ddata_in[i]); } } } return nerrors; }