X-Git-Url: https://yaffs.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=direct%2Ftest-framework%2Fbasic-tests%2Fdtest.c;h=60d17498c7481193f6f9a2eb9eb687dcee4bc008;hb=f83f5b03c1eea3fe26a0929583ffbd16df7c64f0;hp=dbd194fba236872b47ce1b5571f87521f71d37e6;hpb=9545c19fb2de4e3578eb63329f99754dd5041b55;p=yaffs2.git

diff --git a/direct/test-framework/basic-tests/dtest.c b/direct/test-framework/basic-tests/dtest.c
index dbd194f..60d1749 100644
--- a/direct/test-framework/basic-tests/dtest.c
+++ b/direct/test-framework/basic-tests/dtest.c
@@ -18,9 +18,11 @@
 #include <time.h>
 #include <ctype.h>
 
+
 #include "yaffsfs.h"
 
 #include "yaffs_guts.h" /* Only for dumping device innards */
+#include "yaffs_endian.h" /*For testing the swap_u64 macro */
 
 extern int yaffs_trace_mask;
 
@@ -2711,6 +2713,50 @@ void basic_utime_test(const char *mountpt)
 
 }
 
+void print_binary(u64 val){
+	int count = 0;
+	for (int i= 63; i>=0; i --) {
+		if (count == 0){
+			printf(" ");
+		}
+		if ((((u64)1) << i) & val) {
+			printf("1");
+		} else {
+			printf("0");
+		}
+		count = (count +1) % 8;
+	}
+}
+
+void testing_swap_u64() {
+	int numberOfFailedTests = 0;
+	for (int i =0; i < 8; i ++) {
+		u64 startingNumber = (0xffLLu << (i*8));
+		u64 expected = (0xffLLu << (64 - (i*8) -8));
+		u64 converted = swap_u64(startingNumber);
+		if (converted != expected) {
+			numberOfFailedTests ++;
+			printf("numbers do not match.\n");
+			printf("0xff\t\t\t");
+			print_binary(0xff);
+			printf("\nStarting Number \t");
+            print_binary(startingNumber);
+			printf("\nExpecting \t\t");
+			print_binary(expected);
+			printf("\nConverted \t\t");
+			print_binary(converted);
+
+			printf("\n");
+		}
+	}
+	if (numberOfFailedTests){
+		printf("testing_swap failed %d tests\n", numberOfFailedTests);
+	} else {
+		printf("testing_swap_u64 passed all tests\n");
+	}
+}
+
+
 void size_utime_test(const char *mountpt)
 {
 	char name[100];
@@ -2743,8 +2789,33 @@ void size_utime_test(const char *mountpt)
 	//yaffs_stat already uses 64 bits for both wince and unix times.
 	//To see if we are using 32 or 64 bit time, save a large number into the time and
 	//see if it overflows.
+	long bitsInTime = 8*sizeof(st.yst_ctime);
+	printf("the times are %ld bits long\n", bitsInTime);
+
+	//two testcases
+	if (bitsInTime == 64) {
+		//no need to test the overflow. Just check that it can be retrieved intact.
+
+			//use u64 variables in case utb truncates the values to 32 bit time by accident.
+			u64 start = 0xfffff;
+			u64 end = 	0xffffff;
+
+        	utb.actime =  start;
+        	utb.modtime = end;
+
+        	result = yaffs_futime(h,&utb);
+        	yaffs_fstat(h,&st);
+        	if (st.yst_atime == start && st.yst_mtime == end) {
+        		printf("successfully stored and retrevied a 64 bit number for atime and modtime\n");
+        	} else {
+        		printf("failed to store and retrieve a 64 bit number for atime and modtime\n");
+
+        	}
+	} else {
+		//it is a 32 bit number. Check to see that it overflowed.
+
+	}
 
-	printf("the times are %ld bits long\n", 8*sizeof(st.yst_ctime));
 
 	//here are the last access and modification times.
 	utb.actime = 1000;
@@ -3617,6 +3688,7 @@ int main(int argc, char *argv[])
 	 //readdir_test("/nand");
 
 	 basic_utime_test("/nand");
+	 testing_swap_u64();
 	 size_utime_test("/nand");
 	 //case_insensitive_test("/nand");