diff -r 990734f548ef -r 655020a30e77 test/buffer_tests.c
--- a/test/buffer_tests.c	Sun Nov 04 20:50:12 2012 +0100
+++ b/test/buffer_tests.c	Fri Nov 30 13:10:58 2012 +0100
@@ -5,11 +5,8 @@
 #include "buffer_tests.h"
 
 UCX_TEST_IMPLEMENT(test_ucx_buffer_seektell) {
-    char *buffer = (char*) malloc(16);
-    memset(buffer, 32, 7);
-    buffer[7] = 0;
-
-    UcxBuffer *b = ucx_buffer_new(buffer, 16, UCX_BUFFER_DEFAULT);
+    UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT);
+    b->size = 16; // less than capacity
     int r;
 
     UCX_TEST_BEGIN
@@ -34,43 +31,81 @@
 
     r = ucx_buffer_seek(b, -5, SEEK_END);
     UCX_TEST_ASSERT(r == 0, "seek END-5 failed");
-    UCX_TEST_ASSERT(b->pos == 2, "seek END-5 set wrong position");
+    UCX_TEST_ASSERT(b->pos == 11, "seek END-5 set wrong position");
 
-    r = ucx_buffer_seek(b, -10, SEEK_END);
+    r = ucx_buffer_seek(b, -20, SEEK_END);
     UCX_TEST_ASSERT(r != 0, "seek END beyond bounds shall fail");
-    UCX_TEST_ASSERT(b->pos == 2,
+    UCX_TEST_ASSERT(b->pos == 11,
             "failed seek shall leave pos unchanged");
 
     UCX_TEST_END
 
     ucx_buffer_free(b);
+}
+
+UCX_TEST_IMPLEMENT(test_ucx_buffer_putc) {
+    char *buffer = (char*) malloc(16);
+    memset(buffer, 32, 16);
+
+    UcxBuffer *b = ucx_buffer_new(buffer, 16, UCX_BUFFER_DEFAULT);
+    b->size = b->capacity;
+    int r;
+
+    UCX_TEST_BEGIN
+
+    ucx_buffer_putc(b, '0');
+    ucx_buffer_putc(b, '0');
+    ucx_buffer_putc(b, '0');
+    
+    UCX_TEST_ASSERT(b->pos == 3, "pos wrong after first 3 puts");
+    ucx_buffer_seek(b, 10, SEEK_CUR);
+    
+    ucx_buffer_putc(b, '0');
+    ucx_buffer_putc(b, '0');
+    ucx_buffer_putc(b, '0');
+    
+    UCX_TEST_ASSERT(b->pos == 16, "pos wrong after last 3 puts");
+    UCX_TEST_ASSERT(ucx_buffer_eof(b), "eof not set");
+    UCX_TEST_ASSERT(ucx_buffer_putc(b, 48) == EOF,
+            "put shall return EOF when buffer is full");
+    
+    ucx_buffer_seek(b, 3, SEEK_SET);
+    ucx_buffer_putc(b, 'a');
+    ucx_buffer_putc(b, 'b');
+    ucx_buffer_putc(b, 'c');
+    
+    UCX_TEST_ASSERT(b->size == 16, "wrong size after seek and puts");
+    UCX_TEST_ASSERT(memcmp(buffer, "000abc       000", 16) == 0,
+            "buffer contains incorrect content");
+
+    UCX_TEST_END
+
+    ucx_buffer_free(b);
     free(buffer);
 }
 
-UCX_TEST_IMPLEMENT(test_ucx_buffer_putc) {
-    char *buffer = (char*) malloc(16);
-    memset(buffer, 32, 16);
-
-    UcxBuffer *b = ucx_buffer_new(buffer, 16, UCX_BUFFER_DEFAULT);
-    int r;
-
+UCX_TEST_IMPLEMENT(test_ucx_buffer_putc_ax) {
+    UcxBuffer *b = ucx_buffer_new(NULL, 2, UCX_BUFFER_AUTOEXTEND);
+    
     UCX_TEST_BEGIN
-
-    ucx_buffer_putc(b, 48); ucx_buffer_putc(b, 48); ucx_buffer_putc(b, 48);
-    UCX_TEST_ASSERT(b->pos == 3, "pos wrong after first 3 puts");
-    ucx_buffer_seek(b, 10, SEEK_CUR);
-    ucx_buffer_putc(b, 48); ucx_buffer_putc(b, 48); ucx_buffer_putc(b, 48);
-    UCX_TEST_ASSERT(b->pos == 16, "pos wrong after last 3 puts");
-    UCX_TEST_ASSERT(ucx_buffer_eof(b), "eof not set");
-    UCX_TEST_ASSERT(ucx_buffer_putc(b, 48) == EOF,
-            "put shall return EOF when buffer is full");
-    UCX_TEST_ASSERT(memcmp(buffer, "000          000", 16) == 0,
-            "buffer contains incorrect content");
-
+    
+    ucx_buffer_putc(b, '0');
+    ucx_buffer_putc(b, '1');
+    
+    UCX_TEST_ASSERT(b->pos == 2, "pos wrong after first 2 puts");
+    UCX_TEST_ASSERT(b->capacity == 2, "buffer erroneously extended");
+    
+    ucx_buffer_putc(b, 'a');
+    
+    UCX_TEST_ASSERT(b->pos == 3, "pos wrong after 1 put");
+    UCX_TEST_ASSERT(b->capacity == 4, "buffer not properly extended");
+    UCX_TEST_ASSERT(b->size == 3, "wrong buffer size");
+    
+    UCX_TEST_ASSERT(b->space[2] == 'a', "wrong content");
+    
     UCX_TEST_END
-
-    ucx_buffer_free(b);
-    free(buffer);
+    
+    
 }
 
 UCX_TEST_IMPLEMENT(test_ucx_buffer_getc) {
@@ -81,6 +116,7 @@
     }
 
     UcxBuffer *b = ucx_buffer_new(buffer, 16, UCX_BUFFER_DEFAULT);
+    b->size = b->capacity;
     int r;
 
     UCX_TEST_BEGIN
@@ -132,7 +168,7 @@
     memset(buffer, 49, 16);
     ucx_buffer_seek(b, 0, SEEK_SET);
     r = ucx_buffer_write((void*)threebytestring, 3, 6, b);
-    UCX_TEST_ASSERT(r == 15, "three byte string not correctly trimed");
+    UCX_TEST_ASSERT(r == 5, "three byte string not correctly trimed");
     UCX_TEST_ASSERT(b->pos == 15,
             "position after write of three byte string incorrect");
     UCX_TEST_ASSERT(!ucx_buffer_eof(b), "eof shall not be set");
@@ -146,7 +182,7 @@
 }
 
 UCX_TEST_IMPLEMENT(test_ucx_buffer_write_ax) {
-    char *buffer = (char*) malloc(4);
+    char *buffer = (char*) malloc(16);
 
     UcxBuffer *b = ucx_buffer_new(buffer, 16,
             UCX_BUFFER_AUTOEXTEND | UCX_BUFFER_AUTOFREE);
@@ -158,7 +194,7 @@
     r = ucx_buffer_write((void*)teststring, 1, 20, b);
     buffer = (char*) b->space; /*autoextend enabled, we MUST retrieve pointer*/
     UCX_TEST_ASSERT(r == 20, "not all characters written");
-    UCX_TEST_ASSERT(b->size == 32, "buffer not properly extended");
+    UCX_TEST_ASSERT(b->capacity == 32, "buffer not properly extended");
     UCX_TEST_ASSERT(b->pos == 20, "position incorrect");
     UCX_TEST_ASSERT(memcmp(buffer,
             "this is way too much\0\0\0\0\0\0\0\0\0\0\0\0", 32) == 0,
@@ -170,54 +206,53 @@
 }
 
 UCX_TEST_IMPLEMENT(test_ucx_buffer_read) {
-    char *buffer = (char*) malloc(16);
-    memset(buffer, 56, 8);
-    for (int i = 8; i < 16 ; i++) {
-        buffer[i] = 40+i;
-    }
-
-    UcxBuffer *b = ucx_buffer_new(buffer, 16, UCX_BUFFER_DEFAULT);
+    UcxBuffer *b = ucx_buffer_new(NULL, 8, UCX_BUFFER_AUTOFREE);
+    
+    char buf[32];
+    memset(buf, 'X', 32);
     int r;
-
+    
     UCX_TEST_BEGIN
-
-    char rb[16];
-    memset(rb, 32, 16);
-
-    ucx_buffer_seek(b, 8, SEEK_SET);
-    r = ucx_buffer_read(rb, 1, 16, b);
-    UCX_TEST_ASSERT(r == 8, "read did not stop at buffer end");
-    UCX_TEST_ASSERT(memcmp(rb, "01234567        ", 16) == 0,
+    
+    ucx_buffer_write("01234567", 1, 8, b);
+    UCX_TEST_ASSERT(b->pos == 8, "buffer not correctly filled");
+    b->pos = 0;
+    
+    r = ucx_buffer_read(buf, 1, 2, b);
+    UCX_TEST_ASSERT(r == 2, "wrong number of bytes read");
+    UCX_TEST_ASSERT(buf[0] == '0' && buf[1] == '1' && buf[2] == 'X',
             "buffer incorrect after first read");
-    UCX_TEST_ASSERT(ucx_buffer_eof(b), "eof shall be set");
-
+    
+    r = ucx_buffer_read(buf + 2, 1, 8, b);
+    UCX_TEST_ASSERT(r == 6, "wrong number of bytes read(2)");
+    UCX_TEST_ASSERT(memcmp(buf, "01234567XX", 10) == 0,
+            "buffer incorrect after second read");
+    
+    memset(buf, 'X', 32);
     ucx_buffer_seek(b, 0, SEEK_SET);
-    r = ucx_buffer_read(rb+8, 1, 8, b);
-    UCX_TEST_ASSERT(r == 8, "read did not read the specified amount of bytes");
-    UCX_TEST_ASSERT(memcmp(rb, "0123456788888888", 16) == 0,
-                "buffer incorrect after second read");
-
-    ucx_buffer_seek(b, 0, SEEK_SET);
-    r = ucx_buffer_read(rb, 3, 6, b);
-    UCX_TEST_ASSERT(r == 15,
-            "three byte read did not read the desired amount of bytes");
-    UCX_TEST_ASSERT(memcmp(rb, "8888888801234568", 16) == 0,
-                    "buffer incorrect after three byte read");
-
+    r = ucx_buffer_read(buf, 3, 3, b);
+    
+    UCX_TEST_ASSERT(r == 2, "wrong number of blocks read");
+    UCX_TEST_ASSERT(memcmp(buf, "012345XX", 8) == 0,
+            "buffer incorrect after three byte read");
+    
+    
     UCX_TEST_END
-
-    ucx_buffer_free(b);
-    free(buffer);
+    
+    
 }
 
 UCX_TEST_IMPLEMENT(test_ucx_buffer_extract) {
     char *buffer = (char*) malloc(16);
     strcpy(buffer, "this is a test!");
 
-    UcxBuffer *src = ucx_buffer_new(buffer, 16, UCX_BUFFER_AUTOFREE),
-            *dst = ucx_buffer_extract(src, 5, 5, UCX_BUFFER_DEFAULT);
+    UcxBuffer *src = ucx_buffer_new(buffer, 16, UCX_BUFFER_AUTOFREE);
+    src->size = 15;
+    UcxBuffer *dst = ucx_buffer_extract(src, 5, 5, UCX_BUFFER_DEFAULT);
 
     UCX_TEST_BEGIN
+    UCX_TEST_ASSERT(dst != NULL, "ucx_buffer_extract returned NULL");
+            
     UCX_TEST_ASSERT((dst->flags & UCX_BUFFER_AUTOFREE) == UCX_BUFFER_AUTOFREE,
             "autofree flag shall be enforced");
     UCX_TEST_ASSERT(dst->size == 5, "wrong size for new buffer");
@@ -234,3 +269,48 @@
     ucx_buffer_free(dst);
     ucx_buffer_free(src);
 }
+
+UCX_TEST_IMPLEMENT(test_ucx_buffer_generic_copy) {
+    UcxBuffer *b1 = ucx_buffer_new(NULL, 64, UCX_BUFFER_DEFAULT);
+    UcxBuffer *b2 = ucx_buffer_new(NULL, 2, UCX_BUFFER_AUTOEXTEND);
+    
+    UCX_TEST_BEGIN
+    
+    ucx_buffer_write("01234567", 1, 8, b1);
+    ucx_buffer_write("abcdefgh", 1, 8, b1);
+    UCX_TEST_ASSERT(b1->size == 16, "failed to fill buffer b1");
+    ucx_buffer_seek(b1, 0, SEEK_SET);
+    
+    size_t ncp = ucx_buffer_copy(b1, b2, ucx_buffer_read, ucx_buffer_write);
+    UCX_TEST_ASSERT(ncp == 16, "wrong number of copied bytes");
+    UCX_TEST_ASSERT(b2->size == 16, "b2 has wrong size");
+    UCX_TEST_ASSERT(memcmp(b1->space, b2->space, 16) == 0,
+            "b1 and b2 have not the same content");
+    
+    memset(b2->space, 0, b2->capacity);
+    b2->pos = 0;
+    b2->size = 0;
+    ucx_buffer_seek(b1, 0, SEEK_SET);
+    
+    FILE *file = tmpfile();
+    UCX_TEST_ASSERT(file, "test file cannot be opened, test aborted");
+    
+    ncp = ucx_buffer_copy(b1, file, ucx_buffer_read, fwrite);
+    UCX_TEST_ASSERT(ncp == 16, "copied wrong number of bytes to file");
+    
+    fseek(file, 0, SEEK_SET);
+    
+    ncp = ucx_buffer_copy(file, b2, fread, ucx_buffer_write);
+    UCX_TEST_ASSERT(ncp == 16, "copied wrong number of bytes from file");
+    
+    UCX_TEST_ASSERT(memcmp(b1->space, b2->space, 16) == 0,
+            "b1 and b2 content mismatch");
+    
+    fclose(file);
+    
+    
+    UCX_TEST_END
+    
+    ucx_buffer_free(b1);
+    ucx_buffer_free(b2);
+}