@@ -305,14 +305,12 @@ redata_chunk_movedata(redata_t *redata, int chunkfrom, long posfrom, int chunkto

                 /* from==to */

                 rechunk_t *chunk=redata->chunks[chunkfrom];

                 memcpy(redata->tmpchunk->data,chunk->data+posfrom,size);

-                if(posto>posfrom) {

-                        int inside=(posto-posfrom)-size;

-                        memmove(chunk->data+posfrom,chunk->data+posto-inside,inside);

-                        memcpy(chunk->data+posfrom+inside,redata->tmpchunk->data,size);

-                } else {

-                        int inside=(posto-posfrom);

-                        memmove(chunk->data+posfrom+size-inside,chunk->data+posto,inside);

+                if(posfrom>posto) {

+                        memmove(chunk->data+posto+size,chunk->data+posto,posfrom-posto);

                         memcpy(chunk->data+posto,redata->tmpchunk->data,size);

+                } else {

+                        memmove(chunk->data+posfrom,chunk->data+posfrom+size,posto-posfrom-size);

+                        memcpy(chunk->data+posto-size,redata->tmpchunk->data,size);

                 }

                 chunk->whatin_fresh=0;

         }

@@ -1168,8 +1166,8 @@ redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostac

                                 return(-1); /* invalid pos or insuf. mem */

                         if(pos!=0)

                                 chunkno++;

-                        if(spos==0)

-                                schunkno--;

+                        if(spos!=0)

+                                schunkno++;

                         if(dpos!=0)

                                 dchunkno++;

                         if(chunkno<0 || schunkno<0 || dchunkno<0

@@ -1178,12 +1176,12 @@ redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostac

                         /* reorder inplace inverting the bytes (as in flipping a image) */

                         if(chunkno<dchunkno) {

                                 meminvert(redata->chunks+chunkno,redata->chunks+dchunkno);

-                                meminvert(redata->chunks+chunkno,redata->chunks+dchunkno-(schunkno-chunkno));

                                 meminvert(redata->chunks+dchunkno-(schunkno-chunkno),redata->chunks+dchunkno);

+                                meminvert(redata->chunks+chunkno,redata->chunks+dchunkno-(schunkno-chunkno));

                         } else {

-                                meminvert(redata->chunks+dchunkno,redata->chunks+chunkno);

+                                meminvert(redata->chunks+dchunkno,redata->chunks+schunkno);

                                 meminvert(redata->chunks+dchunkno,redata->chunks+dchunkno+(schunkno-chunkno));

-                                meminvert(redata->chunks+dchunkno+(schunkno-chunkno),redata->chunks+chunkno);

+                                meminvert(redata->chunks+dchunkno+(schunkno-chunkno),redata->chunks+schunkno);

                         }

                 }

         }

@@ -43,26 +43,38 @@ main(int argc, char *argv[])

         static int sizes[]={-1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,30,31,32,33,63,64,65,127,128,129,1023,1024,1025,16384};

         test_t tests[]={

                 {"newfile_16",test_newfile,PREFIX "FILE", NULL, 16, 0},

-#if 0 /* more newfile tests (VERY slow) */

                 {"newfile_1024",test_newfile,PREFIX "FILE", NULL, 1024, 0},

                 {"newfile_32767",test_newfile,PREFIX "FILE", NULL, 32767, 0},

                 {"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},

-#endif

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

                 {"testedit_del",test_edit,PREFIX "EDIT", "A0$Testing add/del$D8$add/$",0,0},

+                {"testedit_move",test_edit,PREFIX "EDIT", "A0$This is a text to move.$M17,7$ move$",0,0},

         };

+        int flag_exit=0,flag_all=0;

         redata_t *redata;

         int i,s;

         int nerrors,total;

         char *res;

+        for(i=1;i<argc;i++) {

+                if(strcmp(argv[i],"--help")==0) {

+                        fprintf(stderr,"Syntax: %s [--all] [--exit] [--help]\nExplanation:\n\t--all: do even the slow tests\n\t--exit: exit program at first unsuccessful test\n\t--help: this text\n",argv[0]);

+                        return(1);

+                } else if(strcmp(argv[i],"--all")==0) {

+                        flag_all=1;

+                } else if(strcmp(argv[i],"--exit")==0) {

+                        flag_exit=1;

+                }

+        }

         nerrors=0;

         total=0;

         for(s=0;s<(sizeof(sizes)/sizeof(sizes[0]));s++) {

                 if(sizes[s]!=-1)

                         fprintf(stderr,"SIZE: %i\n",sizes[s]);

                 for(i=0;i<(sizeof(tests)/sizeof(tests[0]));i++,total++) {

+                        if(!flag_all && tests[i].int1>=1024)

+                                continue; /* too slow: skip unless testing --all */

                         if((redata=redata_init())==NULL) {

                                 fprintf(stderr,"ERROR: problem initializing redata module\n");

                                 return(1);

@@ -76,11 +88,11 @@ main(int argc, char *argv[])

                         } else {

                                 fprintf(stderr," ERROR: %s\n",res);

                                 nerrors++;

-#if 0

-/* exit on first error */

-s=sizeof(sizes)/sizeof(sizes[0]);

-break;

-#endif

+                                if(flag_exit) {

+                                        /* exit on first error */

+                                        s=sizeof(sizes)/sizeof(sizes[0]);

+                                        break;

+                                }

                         }

                         redata_free(redata),redata=NULL;

                 }

@@ -168,7 +180,7 @@ test_edit(redata_t *redata, char *filename, char *edits, int filesize, int seed)

         int k;

         int cursize,maxsize;

         char *ptr;

-        int l;

+        int l,o;

         char *mem;

         char endcode;

         char *ptrend;

@@ -248,6 +260,53 @@ if(k!=0) redata_save(redata,"test.pre");

                                 cursize-=size;

                                 ptr+=size;

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

+                        } else if(*ptr=='M') {

+                                /* M<origpos>,<destpos><endchar><text><endchar> */

+                                ptr++;

+                                errno=0;

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

+                                if(errno!=0) {

+                                        if(mem!=NULL)

+                                                free(mem),mem=NULL;

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

+                                }

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

+                                errno=0;

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

+                                if(errno!=0) {

+                                        if(mem!=NULL)

+                                                free(mem),mem=NULL;

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

+                                }

+                                endcode=*ptr;

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

+                                ptrend=strchr(ptr,endcode);

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

+                                size=ptrend-ptr;

+                                if(l<0 || (l+size)>cursize || o<0 || o>cursize || (o>=l && o<(l+size))) {

+                                        if(mem!=NULL)

+                                                free(mem),mem=NULL;

+                                        return("test_edit(): internal error: invalid pasition or size");

+                                }

+                                if(k!=0) {

+                                        if(memcmp(mem+l,ptr,size)!=0

+                                          || redata_data_compare(redata,l,ptr,size)!=0) {

+                                                if(mem!=NULL)

+                                                        free(mem),mem=NULL;

+                                                return("test_edit(): internal error: move data doesn't match");

+                                        }

+                                        /* editing */

+                                        if(l>o) {

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

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

+                                        } else {

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

+                                                memcpy(mem+o-size,ptr,size);

+                                        }

+                                        redata_op_move(redata,l,size,o,NULL);

+                                }

+                                ptr+=size;

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

                         } else {

                                 if(mem!=NULL)

                                         free(mem),mem=NULL;