Home
Manual
Packages
Global Index
Keywords
Quick Reference
|
/*
TESTB.I
A comprehensive test of the native-Yorick binary I/O functions.
Also, read back PDB files created by Stewart Brown's pdtest program,
and create facsimile of such files (although doesn't write PDB-style
pointers).
$Id: testb.i,v 1.1 1993/08/27 18:50:06 munro Exp $
*/
/* Copyright (c) 1994. The Regents of the University of California.
All rights reserved. */
func testb (do_stats)
/* DOCUMENT testb
or testb, 1 (prints yorick_stats)
Perform systematic test of all features of Yorick's binary I/O
package. This extends the simple test in testp.i.
*/
{
local varCs, varCa, varSs, varSa, varIs, varIa, varLs, varLa;
local varFs, varFa, varDs, varDa, varZs, varZa, varSIs, varSIa;
local bundle;
local varQs, varPs, varQa, varPa, linkedList, mixed;
/* begin by writing a simple flat file */
write, " First test is to write flat files:";
tester1, "junk", write_flat, read_flat;
/* continue by writing a file with lots of indirections */
write, "\n Second test is to write files with pointers:";
tester1, "junk", write_ptrs, read_ptrs;
/* update the indirect files and write the flat stuff */
write, "\n Third test is to update pointered files with flat data:";
tester2, "junk", write_flat, read_flat, read_ptrs;
/* exhaustive test to and from all other primitive formats */
write, "\n Fourth test is exhaustive check of other primitive formats:";
now= split= array(0.0, 3);
timer, now;
tester3;
timer, now, split;
timer_print, "Time to write/test all formats", split;
/* Contents Log tests */
write, "\n Fifth test is check of Contents Log machinery:";
tester4;
/* History tests */
write, "\n Sixth test is flat history files (be patient):";
timer, now;
tester5;
timer, now, split;
timer_print, "Time to write history files", split;
write, "\n Seventh test is a pointered history file:";
tester6;
rm_hist;
remove, "junk.clog";
remove, "junk.pdb"; remove, "junk.pdbL";
remove, "junkd.pdb"; remove, "junkd.pdbL";
remove, "junkc.pdb"; remove, "junkc.pdbL";
remove, "junks.pdb"; remove, "junks.pdbL";
}
func rm_hist
{
for (i=0 ; i<22 ; i++) remove, swrite(format="junk%02ld.pdb", i);
for (i=0 ; i<22 ; i++) remove, swrite(format="junk%02ld.pdbL", i);
}
func tester1 (base, writer, reader)
{
if (do_stats) "Begin1 "+print(yorick_stats())(1);
write, "Write using native formats"
f= createb(base+".pdb");
if (do_stats) "Created "+print(yorick_stats())(1);
writer, f, 0;
close, f;
if (do_stats) "Closed "+print(yorick_stats())(1);
f= openb(base+".pdb");
if (do_stats) "Opened "+print(yorick_stats())(1);
reader, f, 0;
write, "Write using DEC primitive formats"
g= createb(base+"d.pdb", dec_primitives);
if (do_stats) "Created "+print(yorick_stats())(1);
writer, g, 1;
reader, g, 0;
write, "Write using Sun primitive formats"
h= createb(base+"s.pdb", sun_primitives);
if (do_stats) "Created "+print(yorick_stats())(1);
writer, h, 0;
reader, h, 1;
close, h;
if (do_stats) "Closed S "+print(yorick_stats())(1);
write, "Write using Cray primitive formats"
h= createb(base+"c.pdb", cray_primitives);
if (do_stats) "Created "+print(yorick_stats())(1);
writer, h, 1;
reader, h, 1;
close, h;
if (do_stats) "Closed C "+print(yorick_stats())(1);
close, g;
if (do_stats) "Closed D "+print(yorick_stats())(1);
close, f;
if (do_stats) "Closed N "+print(yorick_stats())(1);
}
func tester2 (base, writer, reader, reader2)
{
if (do_stats) "Begin2 "+print(yorick_stats())(1);
write, "Update using native formats"
f= updateb(base+".pdb");
if (do_stats) "Updating "+print(yorick_stats())(1);
writer, f, 1;
close, f;
if (do_stats) "Closed "+print(yorick_stats())(1);
f= updateb(base+".pdb");
if (do_stats) "Opened "+print(yorick_stats())(1);
reader, f, 1;
reader2, f, 1;
write, "Update using DEC primitive formats"
g= updateb(base+"d.pdb", dec_primitives);
if (do_stats) "Updating "+print(yorick_stats())(1);
writer, g, 0;
reader, g, 1;
reader2, g, 1;
write, "Update using Sun primitive formats"
h= updateb(base+"s.pdb", sun_primitives);
if (do_stats) "Created "+print(yorick_stats())(1);
writer, h, 1;
reader, h, 0;
reader2, h, 0;
close, h;
if (do_stats) "Closed S "+print(yorick_stats())(1);
write, "Update using Cray primitive formats"
h= updateb(base+"c.pdb", cray_primitives);
if (do_stats) "Created "+print(yorick_stats())(1);
writer, h, 0;
reader, h, 0;
reader2, h, 0;
close, h;
if (do_stats) "Closed C "+print(yorick_stats())(1);
close, g;
if (do_stats) "Closed D "+print(yorick_stats())(1);
close, f;
if (do_stats) "Closed N "+print(yorick_stats())(1);
}
func tester3
{
write, "Testing Sun format";
test_full, "junk", sun_primitives;
write, "Testing i86 format";
test_full, "junk", i86_primitives;
write, "Testing alpha format";
test_full, "junk", alpha_primitives;
write, "Testing sgi64 format";
test_full, "junk", sgi64_primitives;
write, "Testing DEC format";
test_full, "junk", dec_primitives;
write, "Testing Cray format";
test_full, "junk", cray_primitives;
write, "Testing XDR format";
test_full, "junk", xdr_primitives;
write, "Testing Mac format";
test_full, "junk", mac_primitives;
write, "Testing Mac long-double format";
test_full, "junk", macl_primitives;
write, "Testing IBM PC format";
test_full, "junk", pc_primitives;
write, "Testing VAX format";
test_full, "junk", vax_primitives;
write, "Testing VAX G-double format";
test_full, "junk", vaxg_primitives;
write, "Testing Sun-3/Sun-2 format";
test_full, "junk", sun3_primitives;
write, "Testing native format";
test_full, "junk";
}
func test_full (base, primitives)
{
write_ptrs, createb(base+".pdb", primitives), 0;
write_flat, updateb(base+".pdb"), 0;
read_flat, openb(base+".pdb"), 0;
read_ptrs, openb(base+".pdb"), 0;
}
func tester4
{
write, "Contents Log -- testing Sun format";
test_clog, "junk", sun_primitives;
write, "Contents Log -- testing DEC format";
test_clog, "junk", dec_primitives;
write, "Contents Log -- testing Cray format";
test_clog, "junk", cray_primitives;
write, "Contents Log -- testing VAX format";
test_clog, "junk", vax_primitives;
write, "Contents Log -- testing native format";
test_clog, "junk";
write, "Non-PDB Contents Log -- testing Sun format";
test_clog, "junk", sun_primitives, 1;
write, "Non-PDB Contents Log -- testing DEC format";
test_clog, "junk", dec_primitives, 1;
write, "Non-PDB Contents Log -- testing Cray format";
test_clog, "junk", cray_primitives, 1;
write, "Non-PDB Contents Log -- testing VAX format";
test_clog, "junk", vax_primitives, 1;
write, "Non-PDB Contents Log -- testing native format";
test_clog, "junk",, 1;
}
func test_clog (base, primitives, nonpdb)
{
if (!nonpdb) {
f= createb(base+".pdb", primitives);
} else {
f= open(base+".pdb", "w+b");
if (is_func(primitives)) primitives, f;
_init_clog, f;
}
write_ptrs, f, 0;
write_flat, f, 0;
if (!nonpdb) dump_clog, f, base+".clog";
close, f;
if (!nonpdb) f= openb(base+".pdb", base+".clog");
else f= openb(base+".pdb");
read_flat, f, 0;
read_ptrs, f, 0;
}
func tester5
{
write, "History -- testing Sun format";
test_hist, "junk00", sun_primitives;
rm_hist;
write, "History -- testing DEC format";
test_hist, "junk00", dec_primitives;
rm_hist;
write, "History -- testing Cray format";
test_hist, "junk00", cray_primitives;
rm_hist;
write, "History -- testing VAX format";
test_hist, "junk00", vax_primitives;
rm_hist;
write, "History -- testing native format";
test_hist, "junk00";
rm_hist;
}
func test_hist (base, primitives)
{
/* No non-record variables in 1st test. */
f= createb(base+".pdb", primitives);
write_hist, f;
close, f;
f= openb(base+".pdb");
read_hist, f;
close, f;
}
test_records= 100;
test_filesize= 8000; /* each record is about 1 kbyte long */
func write_hist (f)
{
for (i=1 ; i<=test_records ; i++) {
time= double(i-1); ncyc= i;
add_record, f, time, ncyc;
if (i==1) set_filesize, f, test_filesize;
save, f, time, ncyc;
write_flat, f, 0;
}
}
func read_hist (f)
{
n= test_records/3;
prime= 27;
if (n%prime == 0) {
prime= 13;
if (n%prime == 0) prime= 0;
}
for (i=1 ; i<=test_records/3 ; i++) {
if (prime) j= (i%prime) + 1;
else j= i;
jt, double(j-1);
if (f.time!=double(j-1) || f.ncyc!=j)
"time or ncyc bad at record "+print(j)(1);
read_flat, f, 0;
}
for (i=test_records/3+1 ; i<=2*(test_records/3) ; i++) {
jc, f, i;
if (f.time!=double(i-1) || f.ncyc!=i)
"time or ncyc bad at record "+print(i)(1);
read_flat, f, 0;
}
i= 2*(test_records/3);
do {
restore, f, time, ncyc;
if (f.time!=double(i-1) || f.ncyc!=i)
"time or ncyc bad at record "+print(i)(1);
read_flat, f, 0;
i++;
} while (jt(f));
if (ncyc<test_records) "jt found only "+print(ncyc)(1)+
" out of "+print(test_records)(1)+" records";
}
func tester6
{
for_hist_test= 1;
f= createb("junk00.pdb");
write_flat, f, 1;
for (i=1 ; i<=23 ; i++) {
time= double(i-1); ncyc= i;
if (i==1) {
/* records with pointers must be built before writing them */
add_record, f;
add_variable, f, -1, "varQs", string;
add_variable, f, -1, "varQa", string, 2, 4;
add_variable, f, -1, "varPs", pointer;
add_variable, f, -1, "varPa", pointer, 2, 3, 2;
add_variable, f, -1, "linkedList", pointer;
add_variable, f, -1, "mixed", Mixed;
save, f, Link;
}
add_record, f, time, ncyc;
if (i==1) set_filesize, f, test_filesize;
save, f, time, ncyc;
write_ptrs, f, 0;
}
close, f;
f= openb("junk00.pdb");
for (i=1 ; i<=23 ; i++) {
j= (17*i)%23 + 1;
jt, double(j-1);
if (f.time!=double(j-1) || f.ncyc!=j)
"time or ncyc bad at record "+print(j)(1);
read_ptrs, f, 1;
read_flat, f, 1;
}
close, f;
rm_hist;
}
func write_flat (f, how)
{
extern varCs, varCa, varSs, varSa, varIs, varIa, varLs, varLa;
extern varFs, varFa, varDs, varDa, varZs, varZa, varSIs, varSIa;
extern bundle;
/* invent a bunch of garbage to be written */
varCs= 'A'; varSs= -37s; varIs= 76n; varLs= 144;
varCa= ['Z', '\370', 'a'];
varSa= short([[0,0,0],[0,-100,100]]);
varIa= int([[[1,2,3,4],[-30,-20,-10,0],[-1,2,-3,4]],
[[0,-30,20,-10],[4,3,2,1],[3,-4,1,-2]]]);
varLa= [123456789, -987654321];
varFs= 1.5f; varDs= -6.022e23; varZs= 1-1i;
varFa= float([[0,0,0],[0,-100,100]]);
varDa= double([[[1,2,3,4],[-30,-20,-10,0],[-1,2,-3,4]],
[[0,-30,20,-10],[4,3,2,1],[3,-4,1,-2]]]);
varZa= [123456789-3.5i, -987654321+0i];
varSIs= Simple(one='Q', two= -137., three= -37s);
varSIa= [varSIs, Simple(one='\370', two= 1.5, three= 37s)];
bundle= Flat(varCs=varCs, varSs=varSs, varIs=varIs, varLs=varLs,
varCa=varCa, varSa=varSa, varIa=varIa, varLa=varLa,
varFs=varFs, varDs=varDs, varZs=varZs, varSIs=varSIs,
varFa=varFa, varDa=varDa, varZa=varZa, varSIa=varSIa);
if (!how) {
save, f, varCs, varSs, varIs, varLs, varCa, varSa, varIa, varLa;
save, f, varFs, varDs, varZs, varSIs, varFa, varDa, varZa, varSIa;
save, f, bundle;
} else {
add_variable, f, -1, "varCs", char;
add_variable, f, -1, "varSs", "short";
add_variable, f, -1, "varIs", int;
add_variable, f, -1, "varLs", "long";
add_variable, f, -1, "varCa", "char", 3;
add_variable, f, -1, "varSa", short, 3, 2;
add_variable, f, -1, "varIa", "int", 4, [2,3,2];
add_variable, f, -1, "varLa", long, [1,2];
save, f, varFs, varDs;
add_variable, f, -1, "varZs", complex;
f.varZs.re= varZs.re;
f.varZs.im= varZs.im;
add_variable, f, -1, "varFa", "float", [1,3], [1,2];
add_variable, f, -1, "varDa", double, [2,4,3], 2;
add_variable, f, -1, "varZa", "complex", 2;
add_member, f, "Simple", -1, "one", char;
add_member, f, "Simple", -1, "two", "double";
add_member, f, "Simple", -1, "three", short;
install_struct, f, "Simple";
add_variable, f, -1, "varSIs", Simple;
add_variable, f, -1, "varSIa", "Simple", 2;
add_variable, f, -1, "bundle", Flat;
f.varCs= varCs;
save, f, varCa, varSs, varIs, varLs;
f.varSa= varSa;
f.varIa(::-1,,1)= varIa(::-1,,1);
f.varIa(,::-1,2)= varIa(,::-1,2);
f.varLa= varLa;
f.varFa([3,1,5,2,4,6])= varFa([3,1,5,2,4,6]);
f.varDa(,[3,1,5,2,4,6])= varDa(,[3,1,5,2,4,6]);
f.varZa(1).re= varZa.re(1);
f.varZa(1).im= varZa.im(1);
f.varZa.re(2)= varZa(2).re;
f.varZa.im(2)= varZa(2).im;
f.varSIs.one= varSIs.one;
f.varSIs.two= varSIs.two;
f.varSIs.three= varSIs.three;
f.varSIa.one= varSIa.one;
f.varSIa.two= varSIa.two;
f.varSIa(1).three= varSIa.three(1);
f.varSIa.three(2)= varSIa(2).three;
save, f, bundle;
}
if (do_stats) "Saved "+print(yorick_stats())(1);
}
func read_flat (f, how)
{
local varCs, varCa, varSs, varSa, varIs, varIa, varLs, varLa;
local varFs, varFa, varDs, varDa, varZs, varZa, varSIs, varSIa;
local bundle;
if (!how) {
restore, f;
} else {
restore, f, varFs, varCa, varDs, varSa;
varCs= f.varCs;
varFa= array(float, 3, 2);
varFa([4,6,2,5,3,1])= f.varFa([4,6,2,5,3,1]);
varSs= f.varSs;
varDa= array(double, 4,3,2);
varDa(4,1:3,::-1)= f.varDa(4,,::-1);
varDa(3:1:-1,..)= f.varDa(3:1:-1,..);
restore, f, varIs, varLs, varIa, varLa;
varZa= array(0i, 2);
varZa.re= f.varZa.re;
varZa.im= f.varZa.im;
varZs= f.varZs;
restore, f, bundle;
bundle.varDa= 0.0;
bundle.varZa= 0.0;
bundle.varDa(4,1:3,::-1)= f.varDa(4,,::-1);
bundle.varDa(3:1:-1,..)= f.varDa(3:1:-1,..);
bundle.varZa(1).re= f.bundle.varZa.re(1);
bundle.varZa(1).im= f.bundle.varZa.im(1);
bundle.varZa.re(2)= f.bundle.varZa(2).re;
bundle.varZa.im(2)= f.bundle.varZa(2).im;
varSIs= f.varSIs;
varSIa= array(Simple, 2);
varSIa(1).one= f.varSIa.one(1);
varSIa.one(2)= f.varSIa(2).one;
varSIa.two= f.varSIa.two;
varSIa.three= f.varSIa.three;
}
if (do_stats) "Restored "+print(yorick_stats())(1);
goofs= [varCs!='A', varSs!=-37s, varIs!=76n, varLs!=144,
anyof(varCa!=['Z', '\370', 'a']),
anyof(varSa!=short([[0,0,0],[0,-100,100]])),
anyof(varIa!=int([[[1,2,3,4],[-30,-20,-10,0],[-1,2,-3,4]],
[[0,-30,20,-10],[4,3,2,1],[3,-4,1,-2]]])),
anyof(varLa!=[123456789, -987654321]),
varFs!=1.5f, abs(varDs+6.022e23)>6.022e11, varZs!=1-1i,
anyof(varFa!=float([[0,0,0],[0,-100,100]])),
anyof(varDa!=double([[[1,2,3,4],[-30,-20,-10,0],[-1,2,-3,4]],
[[0,-30,20,-10],[4,3,2,1],[3,-4,1,-2]]])),
anyof(varZa!=[123456789-3.5i, -987654321+0i]),
struct_neq(varSIs, Simple(one='Q', two= -137., three= -37s)),
struct_neq(varSIa,
[varSIs, Simple(one='\370', two= 1.5, three= 37s)]),
struct_neq(bundle,
Flat(varCs=varCs, varSs=varSs, varIs=varIs, varLs=varLs,
varCa=varCa, varSa=varSa, varIa=varIa, varLa=varLa,
varFs=varFs, varDs=varDs, varZs=varZs,
varFa=varFa, varDa=varDa, varZa=varZa,
varSIs=varSIs, varSIa=varSIa))];
if (anyof(goofs)) {
"read_flat failed -- goof flags are:";
goofs;
}
if (do_stats) "Checked "+print(yorick_stats())(1);
}
func write_ptrs (f, how)
{
extern varQs, varPs, varQa, varPa, linkedList, mixed;
extern varCs, varZa, varFa, varDa; /* referenced by ptrs */
varCs= 'A';
varFa= float([[0,0,0],[0,-100,100]]);
varDa= double([[[1,2,3,4],[-30,-20,-10,0],[-1,2,-3,4]],
[[0,-30,20,-10],[4,3,2,1],[3,-4,1,-2]]]);
varZa= [123456789-3.5i, -987654321+0i];
/* invent a bunch of garbage to be written */
varQs= "Hello, world!";
varPs= pointer(varQs);
varQa= [["a", "bc"], ["def", "ghij"], ["klmn", "op"], [string(0), ""]];
varPa= [[[&varCs, &varDa], [&varZa, &varDa], [&varPs, &varDa]],
[[&varFa, &varDa], [&varDa, &varPs], [&varQa, &varQa]]];
linkedList= &Link(name="second", index=2);
linkedList->next= &Link(next=linkedList, name="third", index=3);
linkedList->next->next= &Link(name="last", index=4);
linkedList= &Link(next=linkedList, name="first", index=1);
mixed= Mixed(varPs=varPs, s=-37s, varQa=varQa, varQs=varQs,
links=linkedList, varPa=varPa);
if (!how) {
/* This should produce maximum number of duped pointers. */
if (!for_hist_test) save, f, complex, Link;
save, f, varQs, varQa, varPs, varPa, linkedList, mixed;
} else {
/* Piecemeal writes result in some pointee rewrites. */
add_variable, f, -1, "varQs", string;
add_variable, f, -1, "varQa", "string", 2, 4;
add_variable, f, -1, "varPs", "pointer";
add_variable, f, -1, "varPa", pointer, [3,2,3,2];
save, f, complex, varQs;
f.varQa(,::-1)= varQa(,::-1);
f.varPs= varPs;
f.varPa(2,1:3)= varPa(2,1:3);
f.varPa(1,4:6)= varPa(1,4:6);
add_member, f, "Link", -1, "next", pointer;
add_member, f, "Link", -1, "name", "string";
add_member, f, "Link", -1, "index", "long";
install_struct, f, "Link";
add_variable, f, -1, "linkedList", "pointer";
save, f, mixed;
f.linkedList= linkedList;
f.varPa(2,4:6)= varPa(2,4:6);
f.varPa(1,1:3)= varPa(1,1:3);
}
if (do_stats) "Saved ps "+print(yorick_stats())(1);
}
func read_ptrs (f, how)
{
local varQs, varPs, varQa, varPa, linkedList, mixed;
extern varCs, varZa, varFa, varDa; /* referenced by ptrs */
if (!how) {
/* This should produce maximum number of duped pointers. */
restore, f, varQs, varPs, varQa, varPa, linkedList, mixed;
} else {
/* Piecemeal reads result in some pointee rereads. */
varQs= f.varQs;
varQa= array(string, 2, 4);
mixed= f.mixed;
varQa(,::-1)= f.varQa(,::-1);
varPa= array(pointer, 2, 3, 2);
varPa(1,::-1,2)= f.varPa(1,::-1,2);
linkedList= f.linkedList;
varPa(2,,2)= f.varPa(2,,2);
varPs= f.varPs;
varPa(..,1)= f.varPa(..,1);
mixed.varPa= &[];
mixed.varPa(::-1,..)= f.mixed.varPa(::-1,..)
}
if (do_stats) "Restored "+print(yorick_stats())(1);
goofs= [varQs!="Hello, world!",
anyof(varQa!=[["a", "bc"], ["def", "ghij"],
["klmn", "op"], [string(0), ""]]),
string(varPs)!="Hello, world!",
*varPa(1,1,1)!=varCs, anyof(*varPa(2,1,1)!=varDa),
anyof(*varPa(1,2,1)!=varZa), anyof(*varPa(2,2,1)!=varDa),
string(*varPa(1,3,1))!="Hello, world!", anyof(*varPa(2,3,1)!=varDa),
anyof(*varPa(1,1,2)!=varFa), anyof(*varPa(2,1,2)!=varDa),
anyof(*varPa(1,2,2)!=varDa), string(*varPa(2,2,2))!="Hello, world!",
anyof(*varPa(1,3,2)!=varQa), anyof(*varPa(2,3,2)!=varQa)];
if (anyof(goofs)) {
"read_ptrs failed on simple string or pointer -- goof flags are:";
goofs;
}
ll1= linkedList;
ll3= linkedList->next->next;
goofs= [ll1->name!="first", ll1->index!=1,
ll1->next->name!="second", ll1->next->index!=2,
ll3->name!="third", ll3->index!=3,
ll3->next->name!="last", ll3->next->index!=4,
!is_void(*ll3->next->next)];
if (anyof(goofs)) {
"read_ptrs failed on linked list -- goof flags are:";
goofs;
}
ll1= mixed.links;
ll3= mixed.links->next->next;
goofs= [ll1->name!="first", ll1->index!=1,
ll1->next->name!="second", ll1->next->index!=2,
ll3->name!="third", ll3->index!=3,
ll3->next->name!="last", ll3->next->index!=4,
!is_void(*ll3->next->next),
string(mixed.varPs)!="Hello, world!", mixed.s!=-37s,
anyof(mixed.varQa!=[["a", "bc"], ["def", "ghij"],
["klmn", "op"], [string(0), ""]]),
mixed.varQs!="Hello, world!",
anyof(*mixed.varPa(1,2,1)!=varZa),
anyof(*mixed.varPa(2,2,1)!=varDa),
string(*mixed.varPa(1,3,1))!="Hello, world!",
anyof(*mixed.varPa(2,3,1)!=varDa),
anyof(*mixed.varPa(1,1,2)!=varFa),
anyof(*mixed.varPa(2,1,2)!=varDa),
anyof(*mixed.varPa(1,2,2)!=varDa),
string(*mixed.varPa(2,2,2))!="Hello, world!",
anyof(*mixed.varPa(1,3,2)!=varQa),
anyof(*mixed.varPa(2,3,2)!=varQa)];
if (anyof(goofs)) {
"read_ptrs failed on mixed object -- goof flags are:";
goofs;
}
if (do_stats) "Checkedp "+print(yorick_stats())(1);
}
func struct_neq (x, y)
{
members= strtok(strtok(print(structof(x))(2:-1))(2,)," (;")(1,);
m= numberof(members);
for (i=1 ; i<=m ; i++) {
xm= get_member(x, members(i));
ym= get_member(y, members(i));
if (typeof(xm)=="struct_instance") {
if (struct_neq(xm, ym)) return 1;
} else {
if (anyof(xm!=ym)) return 1;
}
}
return 0;
}
struct Simple {
char one;
double two;
short three;
}
struct Flat {
int varIs, varIa(4,3,2);
double varDs;
char varCs;
float varFs, varFa(3,2);
complex varZs, varZa(2);
short varSs, varSa(3,2);
double varDa(4,3,2);
Simple varSIs, varSIa(2);
long varLs, varLa(2);
char varCa(3);
}
struct Link {
pointer next;
string name;
long index;
}
struct Mixed {
pointer varPs;
short s;
string varQa(2,4), varQs;
pointer links, varPa(2,3,2);
}
func pdcheck1 (prefix)
{
write, "Testing <- native...";
pdtest1_check, prefix+"-nat.db1";
write, "Testing <- cray...";
pdtest1_check, prefix+"-cray.db1";
write, "Testing <- dos...";
pdtest1_check, prefix+"-dos.db1";
write, "Testing <- mac...";
pdtest1_check, prefix+"-mac.db1";
write, "Testing <- mips...";
pdtest1_check, prefix+"-mips.db1";
write, "Testing <- sun3...";
pdtest1_check, prefix+"-sun3.db1";
write, "Testing <- sun4...";
pdtest1_check, prefix+"-sun4.db1";
write, "Testing <- vax...";
pdtest1_check, prefix+"-vax.db1";
}
func pdcheck2
{
write, "Testing sun_primitives db1 write...";
pdtest1_write,"junk.pdb", sun_primitives;
pdtest1_check,"junk.pdb";
write, "Testing dec_primitives db1 write...";
pdtest1_write,"junk.pdb", dec_primitives;
pdtest1_check,"junk.pdb";
write, "Testing cray_primitives db1 write...";
pdtest1_write,"junk.pdb", cray_primitives;
pdtest1_check,"junk.pdb";
write, "Testing mac_primitives db1 write...";
pdtest1_write,"junk.pdb", mac_primitives;
pdtest1_check,"junk.pdb";
write, "Testing macl_primitives db1 write...";
pdtest1_write,"junk.pdb", macl_primitives;
pdtest1_check,"junk.pdb";
write, "Testing pc_primitives db1 write...";
pdtest1_write,"junk.pdb", pc_primitives;
pdtest1_check,"junk.pdb";
write, "Testing sun3_primitives db1 write...";
pdtest1_write,"junk.pdb", sun3_primitives;
pdtest1_check,"junk.pdb";
write, "Testing vax_primitives db1 write...";
pdtest1_write,"junk.pdb", vax_primitives;
pdtest1_check,"junk.pdb";
write, "Testing vaxg_primitives db1 write...";
pdtest1_write,"junk.pdb", vaxg_primitives;
pdtest1_check,"junk.pdb";
write, "Testing xdr_primitives db1 write...";
pdtest1_write,"junk.pdb", xdr_primitives;
pdtest1_check,"junk.pdb";
write, "Testing sun_primitives db1 write w/PDB-style pointers...";
pdtest1_write,"junk.pdb", sun_primitives, 1;
pdtest1_check,"junk.pdb";
write, "Testing dec_primitives db1 write w/PDB-style pointers...";
pdtest1_write,"junk.pdb", dec_primitives, 1;
pdtest1_check,"junk.pdb";
write, "Testing cray_primitives db1 write w/PDB-style pointers...";
pdtest1_write,"junk.pdb", cray_primitives, 1;
pdtest1_check,"junk.pdb";
write, "Testing native db1 write...";
pdtest1_write,"junk.pdb";
pdtest1_check,"junk.pdb";
}
func pdtest1_check (filename)
{
f= openb(filename);
vars= *get_vars(f)(1);
if (numberof(vars)!=15) write, "Should be 15 variables in "+filename;
local cs, ss, is, fs, ds, ca, sa, ia, fa2, da, cap, fa2_app, fs_app;
local view, graph;
restore, f;
if (typeof(cs)!="char" || dimsof(cs)(1)!=0 || cs!='Q' /* 0x51 */)
write, "variable cs bad in "+filename;
if (typeof(ss)!="short" || dimsof(ss)(1)!=0 || ss!=-514)
write, "variable ss bad in "+filename;
if (typeof(is)!="int" || dimsof(is)(1)!=0 || is!=10)
write, "variable is bad in "+filename;
if (typeof(fs)!="float" || dimsof(fs)(1)!=0 || float_neq(fs,3.14159))
write, "variable fs bad in "+filename;
if (typeof(ds)!="double" || dimsof(ds)(1)!=0 || double_neq(ds,exp(1)))
write, "variable ds bad in "+filename;
if (typeof(ca)!="char" || dimsof(ca)(1)!=1 || dimsof(ca)(2)!=10 ||
string(&ca)!="Hi there!")
write, "variable ca bad in "+filename;
if (typeof(sa)!="short" || dimsof(sa)(1)!=1 || dimsof(sa)(2)!=5 ||
anyof(sa!=[2,1,0,-1,-2]))
write, "variable sa bad in "+filename;
if (typeof(ia)!="int" || dimsof(ia)(1)!=1 || dimsof(ia)(2)!=5 ||
anyof(ia!=[-2,-1,0,1,2]))
write, "variable ia bad in "+filename;
if (typeof(fa2)!="float" || dimsof(fa2)(1)!=2 ||
anyof(dimsof(fa2)!=[2,3,4]) ||
anyof(float_neq(fa2, [[1,1,1],[2,4,8],[3,9,27],[4,16,64]])))
write, "variable fa2 bad in "+filename;
if (typeof(da)!="double" || dimsof(da)(1)!=1 || dimsof(da)(2)!=4 ||
anyof(double_neq(da, exp([1,2,3,4]))))
write, "variable da bad in "+filename;
if (typeof(cap)!="pointer" || dimsof(cap)(1)!=1 || dimsof(cap)(2)!=3 ||
typeof(*cap(1))!="char" || string(cap(1))!="lev1" ||
typeof(*cap(2))!="char" || string(cap(2))!="lev2" ||
typeof(*cap(3))!="char" || string(cap(3))!="tar fu blat")
write, "variable cap bad in "+filename;
if (typeof(fs_app)!="float" || dimsof(fs_app)(1)!=0 ||
float_neq(fs_app,-3.14159))
write, "variable fs_app bad in "+filename;
if (typeof(fa2_app)!="float" || dimsof(fa2_app)(1)!=2 ||
anyof(dimsof(fa2_app)!=[2,3,4]) ||
anyof(float_neq(fa2_app, [[1,2,3],[1,4,9],[1,8,27],[1,16,81]])))
write, "variable fa2_app bad in "+filename;
if (nameof(structof(view))!="l_frame" || dimsof(view)(1)!=0 ||
float_neq(view.x_min,0.1) || float_neq(view.x_max,1.0) ||
float_neq(view.y_min,-0.5) || float_neq(view.y_max,0.5))
write, "variable view bad in "+filename;
if (nameof(structof(graph))!="plot" || dimsof(graph)(1)!=0 ||
anyof(float_neq(graph.x_axis,[0,.1,.2,.3,.4,.5,.6,.7,.8,.9])) ||
anyof(float_neq(graph.y_axis,[.5,.4,.3,.2,.1,0,-.1,-.2,-.3,-.4])) ||
float_neq(graph.view.x_min,0.1) || float_neq(graph.view.x_max,1.0) ||
float_neq(graph.view.y_min,-0.5) || float_neq(graph.view.y_max,0.5) ||
graph.npts!=10 || string(graph.label)!="test graph")
write, "variable graph bad in "+filename;
}
func float_neq (a, b)
{
return abs(a-b)/(abs(a)+abs(b)+1.e-99) > 1.e-6;
}
func double_neq (a, b)
{
return abs(a-b)/(abs(a)+abs(b)+1.e-99) > 1.e-12;
}
struct l_frame {
float x_min, x_max, y_min, y_max;
}
struct plot {
float x_axis(10), y_axis(10);
int npts;
pointer label;
l_frame view;
}
func pdtest1_write (filename, primitives, pdbptrs)
{
cs= 'Q';
ss= -514s;
is= 10n;
fs= 3.14159;
ds= exp(1);
ca= *pointer("Hi there!");
sa= [2s,1s,0s,-1s,-2s];
ia= [-2n,-1n,0n,1n,2n];
fa2= [[1.f,1.f,1.f],[2.f,4.f,8.f],[3.f,9.f,27.f],[4.f,16.f,64.f]];
da= exp([1,2,3,4]);
cap= [pointer("lev1"), pointer("lev2"), pointer("tar fu blat")];
fs= 3.14159f;
view= l_frame(x_min=0.1,x_max=1.0,y_min=-0.5,y_max=0.5);
graph= plot(x_axis=[0,.1,.2,.3,.4,.5,.6,.7,.8,.9],
y_axis=[.5,.4,.3,.2,.1,0,-.1,-.2,-.3,-.4],
npts=10, label=pointer("test graph"),
view=view);
fa2_app= float([[1,2,3],[1,4,9],[1,8,27],[1,16,81]]);
fs_app= -3.14159f;
if (!pdbptrs) {
save, createb(filename, primitives),\
cs,ss,is,fs,ds, ca,sa,ia,fa2,da, cap, view,graph;
} else {
f= createb(filename, primitives);
save, f, l_frame;
add_member, f, "plot", -1, "x_axis", float, 10;
add_member, f, "plot", -1, "y_axis", float, 10;
add_member, f, "plot", -1, "npts", int;
add_member, f, "plot", -1, "label", "char *";
add_member, f, "plot", -1, "view", l_frame;
install_struct, f, "plot";
save, f, cs,ss,is,fs,ds, ca,sa,ia,fa2,da;
add_variable, f, -1, "cap", "char*", 3;
save, f, cap, view,graph;
close, f;
}
save, updateb(filename), fa2_app,fs_app;
}
|
