i/testb

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;
    }