@@ -32,7 +32,7 @@

 #define UNSAVEDHEADER "REUNSAV\n"

 #define UNSAVEDVERSION "\n000001\0"

-static int redata_hash_gen(redata_t *redata, char *filename, char *resbuf129bytes);

+static int redata_hash_gen(redata_t *redata, char *filename, char *buf, int buflen, char *resbuf129bytes);

 static char *unsaved_genname(char *filename, char *buf, int bufsize);

 static char *securesave_genname(char *filename, char *buf, int bufsize);

 static char *genname(char *filename,char *prefix, char *postfix, char *buf, int bufsize);

@@ -565,7 +565,7 @@ redata_op_redo(redata_t *redata)

 int

 redata_hash(redata_t *redata, char *resbuf129bytes)

 {

-        return(redata_hash_gen(redata,NULL,resbuf129bytes));

+        return(redata_hash_gen(redata,NULL,NULL,0,resbuf129bytes));

 }

 int

@@ -575,12 +575,21 @@ redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes)

                 *resbuf129bytes='\0';

         if(filename==NULL)

                 return(-1);

-        return(redata_hash_gen(redata,filename,resbuf129bytes));

+        return(redata_hash_gen(NULL,filename,NULL,0,resbuf129bytes));

 }

+int

+redata_memhash(redata_t *redata, char *buf, int buflen, char *resbuf129bytes)

+{

+        if(resbuf129bytes!=NULL)

+                *resbuf129bytes='\0';

+        if(buf==NULL || buflen<0)

+                return(-1);

+        return(redata_hash_gen(NULL,NULL,buf,buflen,resbuf129bytes));

+}

 static int

-redata_hash_gen(redata_t *redata, char *filename, char *resbuf129bytes)

+redata_hash_gen(redata_t *redata, char *filename, char *buf, int buflen, char *resbuf129bytes)

 {

         static char conv[]={"0123456789ABCDEF"};

         sha3_context sha3;

@@ -588,9 +597,14 @@ redata_hash_gen(redata_t *redata, char *filename, char *resbuf129bytes)

         int i,c;

         int fd=-1;

         struct stat statbuf;

+        if(resbuf129bytes==NULL)

+                return(-1);  /* sanity check failed */

         if(resbuf129bytes!=NULL)

                 *resbuf129bytes='\0';

-        if(redata==NULL || resbuf129bytes==NULL) {

+        if((redata==NULL && filename==NULL && buf==NULL)

+           || (redata!=NULL && (filename!=NULL || buf!=NULL))

+           || (filename!=NULL && (redata!=NULL || buf!=NULL))

+           || (buf!=NULL && (redata!=NULL || filename!=NULL))) {

                 return(-1); /* sanity check failed */

         }

         if(filename!=NULL) {

@@ -601,10 +615,10 @@ redata_hash_gen(redata_t *redata, char *filename, char *resbuf129bytes)

                 }

         }

         sha3_Init512(&sha3);

-        if(filename==NULL) {

+        if(redata!=NULL) {

                 for(i=0;i<redata->sizechunks;i++)

                         sha3_Update(&sha3,(void *) redata->chunks[i]->data,redata->chunks[i]->useddata);

-        } else {

+        } else if(filename!=NULL) {

                 char buf[16384];

                 int totalread,nread;

                 for(totalread=0,nread=0;totalread<statbuf.st_size;totalread+=nread,nread=0) {

@@ -615,6 +629,8 @@ redata_hash_gen(redata_t *redata, char *filename, char *resbuf129bytes)

                         sha3_Update(&sha3,(void *) buf,nread);

                 }

                 close(fd),fd=-1;

+        } else if(buf!=NULL) {

+                sha3_Update(&sha3,(void *) buf,buflen);

         }

         hash=(unsigned char *)sha3_Finalize(&sha3);

         for(i=0;i<64;i++) {

@@ -86,4 +86,5 @@ int redata_op_redo(redata_t *redata);

 int redata_hash(redata_t *redata, char *resbuf129bytes);

 int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);

+int redata_memhash(redata_t *redata, char *buf, int buflen, char *resbuf129bytes);

@@ -15,6 +15,7 @@

 #include <string.h>

 #include <limits.h>

 #include <fcntl.h>

+#include <errno.h>

 #include "recenteditor_data.h"

@@ -30,7 +31,11 @@ typedef struct test_t  {

         int int2;

 } test_t;

+static char *malloc_data(int size, int seed);

+static int write_file(char *filename, char *buf, int buflen);

+

 char *test_newfile(redata_t *redata, char *filename, char *dummy, int filesize, int dummy2);

+char *test_edit(redata_t *redata, char *filename, char *edits, int filesize, int seed);

 int

 main(int argc, char *argv[])

@@ -42,7 +47,7 @@ main(int argc, char *argv[])

                 {"newfile_32768",test_newfile,PREFIX "FILE", NULL, 32768, 0},

                 {"newfile_32769",test_newfile,PREFIX "FILE", NULL, 32769, 0},

                 {"newfile_131072",test_newfile,PREFIX "FILE", NULL, 131072, 0},

-

+                {"testedit_add",test_edit,PREFIX "EDIT", "A,0,$,Testing add$",0,0},

         };

         redata_t *redata;

         int i;

@@ -67,31 +72,56 @@ main(int argc, char *argv[])

         if(nerrors==0)

                 fprintf(stderr,"All tests passed OK\n");

         else

-                fprintf(stderr,"%i tests failed of %i total tests.\n",nerrors,i);

+                fprintf(stderr,"%i test(s) failed of %i tests run.\n",nerrors,i);

         redata_free(redata),redata=NULL;

         return((nerrors==0)?0:1);

 }

+static char *

+malloc_data(int size, int seed)

+{

+        char *mem;

+        int i;

+        if(size<=0 || (mem=malloc(size))==NULL)

+                return(NULL);

+        memset(mem,0,size);

+        if(seed==0) {

+                for(i=0;i<size;i++)

+                        ((unsigned char *)mem)[i]=(i%256);

+        } else {

+                srandom(*((unsigned int *)(&seed)));

+                for(i=0;i<size;i++)

+                        ((unsigned char *)mem)[i]=(random()&0xff);

+        }

+        return(mem);

+

+}

+

+static int

+write_file(char *filename, char *buf, int buflen)

+{

+        int fd;

+        if((fd=open(filename,O_WRONLY|O_CREAT|O_TRUNC,0644))==-1) {

+                free(buf),buf=NULL;

+                return(-1);

+        }

+        write(fd,buf,buflen);

+        close(fd),fd=-1;

+        return(0);

+}

+

 char *

 test_newfile(redata_t *redata, char *filename, char *dummy, int filesize, int dummy2)

 {

         char *mem;

         char hash129_pre[129];

         char hash129_post[129];

-        int fd,i;

-fprintf(stderr,"\ntest_newfile(%s%s%s,%s,%i,%i);\nResult: ",(filename!=NULL)?"\"":"",(filename!=NULL)?filename:"NULL",(filename!=NULL)?"\"":"",(dummy!=NULL)?dummy:"NULL",filesize,dummy2);

+fprintf(stderr,"\ntest_newfile(%s%s%s,%s%s%s,%i,%i);\nResult: ",(filename!=NULL)?"\"":"",(filename!=NULL)?filename:"NULL",(filename!=NULL)?"\"":"",(dummy!=NULL)?"\"":"",(dummy!=NULL)?dummy:"NULL",(dummy!=NULL)?"\"":"",filesize,dummy2);

         /* prepare file for loading */

-        if((mem=malloc(filesize))==NULL)

+        if((mem=malloc_data(filesize,0))==NULL)

                 return("insuf. mem. for temp. buffer");

-        memset(mem,0,filesize);

-        for(i=0;i<filesize;i++)

-                ((unsigned char *)mem)[i]=(filesize%256);

-        if((fd=open(filename,O_WRONLY|O_CREAT|O_TRUNC,0644))==-1) {

-                free(mem),mem=NULL;

+        if(write_file(filename,mem,filesize)==-1)

                 return("couldn't create temporary file");

-        }

-        write(fd,mem,filesize);

-        close(fd),fd=-1;

         redata_filehash(redata,filename,hash129_pre);

         free(mem),mem=NULL;

         /* load file */

@@ -113,3 +143,116 @@ fprintf(stderr,"\ntest_newfile(%s%s%s,%s,%i,%i);\nResult: ",(filename!=NULL)?"\"

         return(TEST_OK);

 }

+char *

+test_edit(redata_t *redata, char *filename, char *edits, int filesize, int seed)

+{

+        static char errorbuf[256];

+        char progress[256];

+        int k;

+        int cursize;

+        char *ptr;

+        int l;

+        char *mem;

+        char endcode;

+        char *ptrend;

+        int size;

+        char hash129_memold[129];

+        char hash129_mem[129];

+        char hash129_redata[129];

+        mem=NULL;

+fprintf(stderr,"\ntest_edit(%s%s%s,%s%s%s,%i,%i);\nResult: ",(filename!=NULL)?"\"":"",(filename!=NULL)?filename:"NULL",(filename!=NULL)?"\"":"",(edits!=NULL)?"\"":"",(edits!=NULL)?edits:"NULL",(edits!=NULL)?"\"":"",filesize,seed);

+        /* two passes: k==0 count needed memory, k==1 do edits */

+        for(k=0,cursize=filesize,progress[0]='\0';k<2;k++,cursize=0,progress[0]='\0') {

+                for(ptr=edits;*ptr!='\0';) {

+                        if(k!=0) {

+                                redata_memhash(redata,mem,cursize,hash129_memold);

+                        }

+                        if((l=strlen(progress))<(sizeof(progress)-1)) {

+                                progress[l]=(l<(sizeof(progress)-2))?*ptr:'+';

+                                progress[l+1]='\0';

+                        }

+                        if(*ptr=='A') {

+                                /* A,<insertpos>,<endchar>,<text><endchar> */

+                                ptr++;

+                                ptr+=(*ptr==',')?1:0;

+                                errno=0;

+                                l=(int)strtol(ptr,&ptr,10);

+                                if(errno!=0 || l<0 || l>cursize) {

+                                        if(mem!=NULL)

+                                                free(mem),mem=NULL;

+                                        return("test_edit(): error parsing position");

+                                }

+                                ptr+=(*ptr==',')?1:0;

+                                endcode=*ptr;

+                                ptr+=(*ptr!='\0')?1:0;

+                                ptrend=strchr(ptr,endcode);

+                                ptrend=(ptrend==NULL)?ptr+strlen(ptr):ptrend;

+                                size=ptrend-ptr;

+                                if(k!=0) {

+                                        /* editing */

+                                        memmove(mem+l+size,mem+l,size);

+                                        memcpy(mem+l,ptr,size);

+                                        redata_op_add(redata,ptr,size,l);

+                                }

+                                cursize+=size;

+                                ptr+=size;

+                                ptr+=(*ptr!='\0')?1:0;

+                        } else {

+                                if(mem!=NULL)

+                                        free(mem),mem=NULL;

+                                snprintf(errorbuf,sizeof(errorbuf),

+                                  "test_edit(): unknown edit action at pos %i: '%c' (progress: %s)",(int) (ptr-edits),*ptr,progress);

+                                errorbuf[sizeof(errorbuf)-1]='\0';

+                                return(errorbuf);

+                        }

+                        if(k!=0) {

+                                redata_hash(redata,hash129_redata);

+                                redata_memhash(redata,mem,cursize,hash129_mem);

+                                if(strcmp(hash129_redata,hash129_mem)!=0) {

+                                        if(mem!=NULL)

+                                                free(mem),mem=NULL;

+                                        snprintf(errorbuf,sizeof(errorbuf),

+                                          "corrupted edit before pos %i (progress: %s)",(int) (ptr-edits),progress);

+                                        errorbuf[sizeof(errorbuf)-1]='\0';

+                                        return(errorbuf);

+                                }

+                                redata_op_undo(redata);

+                                redata_hash(redata,hash129_redata);

+                                if(strcmp(hash129_redata,hash129_memold)!=0) {

+                                        if(mem!=NULL)

+                                                free(mem),mem=NULL;

+                                        snprintf(errorbuf,sizeof(errorbuf),

+                                          "corrupted undo before pos %i (progress: %s)",(int) (ptr-edits),progress);

+                                        errorbuf[sizeof(errorbuf)-1]='\0';

+                                        return(errorbuf);

+                                }

+                                redata_op_redo(redata);

+                                redata_hash(redata,hash129_redata);

+                                if(strcmp(hash129_redata,hash129_mem)!=0) {

+                                        if(mem!=NULL)

+                                                free(mem),mem=NULL;

+                                        snprintf(errorbuf,sizeof(errorbuf),

+                                          "corrupted redo before pos %i (progress: %s)",(int) (ptr-edits),progress);

+                                        errorbuf[sizeof(errorbuf)-1]='\0';

+                                        return(errorbuf);

+                                }

+                        }

+                }

+                if(k==0) {

+                        /* reserve memory, do init */

+                        if((mem=malloc_data(cursize,seed))==NULL)

+                                return("insuf. mem. for temp. buffer");

+                        if(write_file(filename,mem,filesize)==-1)

+                                return("couldn't create temporary file");

+                        if(redata_load(redata,filename,0)!=0) {

+                                unlink(filename);

+                                return("couldn't load file");

+                        }

+                        unlink(filename);

+                }

+        }

+        if(mem!=NULL)

+                free(mem),mem=NULL;

+        return(TEST_OK);

+}

+