add instructions and steps to know how to do further testing

test/layer1_API.cpp

@@ -11,37 +11,40 @@ int main(int argc, char *argv[]) {
 
     printf("test inode\n");
     INodeOperation inop;
-    inop.initialize(*H);
+    inop.initialize(*H);//for inode initialization and datablock initialization
     char buffer[8] = {0};
-    //test the begining of inode 1~524287
+    /**************************test inode Initialization***************************/
+    //test the begining of inode 1th
     H->rawdisk_read((1) * SECTOR_SIZE, buffer, sizeof(buffer));
     u_int64_t t = 0;
     for (int j = 0; j < 8; j++) 
         t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j);
 
-    assert(t == 2);
+    assert(t == 2);//the first 1th unused inode will store the next unused inode 2th 
-    //test the number before end of inode 524286
+    //test the number before end of inode 524286th
     H->rawdisk_read((MAX_INODE - 2) * SECTOR_SIZE, buffer, sizeof(buffer));
     t = 0;
     for (int j = 0; j < 8; j++) 
         t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j);
     
-    fprintf(stderr,"[t %llu,%d]\n",t,__LINE__);
+    assert(t == MAX_INODE - 1);//store the maximun th inode
-    assert(t == MAX_INODE - 1);
+    //test the end of inode 524287th
-    //test the end of inode 1~524287
     H->rawdisk_read((MAX_INODE - 1) * SECTOR_SIZE, buffer, sizeof(buffer));
     t = 0;
     for (int j = 0; j < 8; j++) 
         t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j);
 
-    assert(t == 0);
+    assert(t == 0);//the end of inode(524287th inode) do not have the next inode address
-    //test the begining of datablock
+    /**************************test datablock Initialization***************************/
-    H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer));
+    //we separate 2048 4kB I/O block(1+2047) as a group and the first I/O block will manage the following 2047 I/O block usage.
+    //the first 8 bytes(0~7) in first I/O block store the address of next first I/O block, the following 256(8~263) bytes record 2047 I/O block usage.
+    //test the begining of free datablock
+    H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer));//the begining of free datablock will store from address (MAX_INODE) * SECTOR_SIZE
     t = 0;
     for (int j = 0; j < 8; j++) 
         t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j);
 
-    assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE);
+    assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE);//the first 8 bytes of 4k I/O block will store the next address(after 2048*4k I/O block)
     //test the end of the datablock
     H->rawdisk_read((MAX_BLOCKNUM - 2048*8) * SECTOR_SIZE, buffer, sizeof(buffer));
     t = 0;
@@ -49,60 +52,66 @@ int main(int argc, char *argv[]) {
         t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j);
 
     assert(t == (MAX_BLOCKNUM)*SECTOR_SIZE);
-    //initialize
+
+    /***************************test inode de/allocation**********************************/
+    //when requesting an inode, the inode_allocation will give you the inode number, we use inode_list to store the sequence allocate inode
+    //arrary version
     int inode_list[20] = {0};
-    printf("Allocate 20 inode num:{");
+    int record_free[10] = {0};//should do a pop up structure to record the free inode 
+    int rec = 9;
+    //printf("Allocate 20 inode num:{");
     for(int i=0;i<20;i++){
         inode_list[i] = inop.inode_allocate(*H);
-        printf(" %d", inode_list[i]);
+        assert(inode_list[i] == i+1);
+        //printf(" %d", inode_list[i]);
     }
-    printf("}\n");
+    //printf("}\n");
-    //free the last 10
-    printf("Free: inode num:{");
     for(int i=10;i<20;i++){
-        inop.inode_free(*H,inode_list[i]);
+        inop.inode_free(*H,inode_list[i]);//free the 10 element from inode_list[10]
-        printf(" %d", inode_list[i]);
+        record_free[i-10] = inode_list[i];
     }
-    printf("}\n");
     //allocate again the last 10
     printf("Allocate again: inode num:{");
     for(int i=10;i<20;i++){
         inode_list[i] = inop.inode_allocate(*H);
-        printf(" %d", inode_list[i]);
+        //printf("inode %d, rec_f %d\n,", inode_list[i],record_free[rec]);
+        assert(inode_list[i] == record_free[rec]);
+        rec--;
     }
     printf("}\n");
-
+    /***************************test direct blocks[48] de/allocation**********************************/
-    printf("The status 20 inode num:{");
+    //after free the datablock, the program will find the first smallest address of datablock to give to the inode
-    for(int i=0;i<20;i++){
+    //should test random resize each node, but should use datablock_free data structure to record
-        printf(" %d", inode_list[i]);
-    }
-    printf("}\n");
-    
     INode inode_inside[10];
+    u_int64_t rec_datablock_free[10][3] = {0};//array version
     for(int i=0;i<10;i++){
         inode_inside[i].inode_construct(inode_list[i],*H);
-        printf("%dth data block starting addres: ", i);
+        //printf("%dth data block starting addres: ", i);
         for(int j=0;j<6;j++){
-            printf("%d," ,inode_inside[i].datablock_allocate(*H));
+            inode_inside[i].datablock_allocate(*H);
+            //printf("%d," ,inode_inside[i].datablock_allocate(*H));
         }
-        printf("\n");
+        //printf("\n");
     }
     for(int i=0;i<10;i++){
-        printf("%dth data block free addres: ", i);
+        //printf("%dth data block free addres: ", i);
-        for(int j=0;j<3;j++){
+        for(int j = 2;j >=0;j--){
-            printf("%d," ,inode_inside[i].datablock_deallocate(*H));
+            rec_datablock_free[i][j] = inode_inside[i].datablock_deallocate(*H);
+            //printf("", rec_datablock_free[i][j]);
         }
-        printf("\n");
+        //printf("\n");
-    }
-    for(int i=0;i<10;i++){
-        printf("%dth data block allocate again addres: ", i);
-        for(int j=0;j<3;j++){
-            printf("%d," ,inode_inside[i].datablock_allocate(*H));
-        }
-        printf("\n");
     }
 
-    printf("}\n");
+    for(int i=0;i<10;i++){
+        //printf("%dth data block allocate again addres: ", i);
+        for(int j=0;j<3;j++){
+            assert(inode_inside[i].datablock_allocate(*H) == rec_datablock_free[i][j]);
+            //printf("%d," ,inode_inside[i].datablock_allocate(*H));
+        }
+        //printf("\n");
+    }
+
+    //printf("}\n");
     delete H;  // Delete the RawDisk object
 
     return 0;