[svn-r26374] Add CMake conversion test for H5_LONG_TO_LDOUBLE_SPECIAL and

H5_LDOUBLE_TO_LONG_SPECIAL (imported from configure.ac).

Fixes: HDFFV-8936

Tested on: ostrich

1 files changed, 118 insertions, 0 deletions

diff --git a/config/cmake/ConversionTests.c b/config/cmake/ConversionTests.c
index 1ee9842..010ee32 100644
--- a/config/cmake/ConversionTests.c
+++ b/config/cmake/ConversionTests.c
@@ -90,6 +90,124 @@ done:
 
 #endif
 
+#ifdef H5_LDOUBLE_TO_LONG_SPECIAL_TEST
+
+int main(void)
+{
+    long double         ld = 20041683600089727.779961L;
+    long                ll;
+    unsigned long       ull;
+    unsigned char       s[16];
+    unsigned char       s2[8];
+    int                 ret = 1;
+
+    if(sizeof(long double) == 16 && sizeof(long) == 8) {
+	/*make sure the long double type has 16 bytes in size and
+	 * 11 bits of exponent.  If it is,
+	 *the bit sequence should be like below.  It's not
+	 *a decent way to check but this info isn't available. */
+	memcpy(s, &ld, 16);
+	if(s[0]==0x43 && s[1]==0x51 && s[2]==0xcc && s[3]==0xf3 &&
+		s[4]==0x85 && s[5]==0xeb && s[6]==0xc8 && s[7]==0xa0 &&
+		s[8]==0xbf && s[9]==0xcc && s[10]==0x2a && s[11]==0x3c) {
+
+	    /* Assign the hexadecimal value of long double type. */
+	    s[0]=0x43; s[1]=0x51; s[2]=0xcc; s[3]=0xf3;
+	    s[4]=0x85; s[5]=0xeb; s[6]=0xc8; s[7]=0xa0;
+	    s[8]=0xbf; s[9]=0xcc; s[10]=0x2a; s[11]=0x3c;
+	    s[12]=0x3d; s[13]=0x85; s[14]=0x56; s[15]=0x20;
+
+	    memcpy(&ld, s, 16);
+
+	    ll = (long)ld;
+	    memcpy(s2, &ll, 8);
+
+	    /* The library's algorithm converts it to 0x 00 47 33 ce 17 af 22 82
+	     * and gets wrong value 20041683600089730 on the IBM Power6 Linux.
+	     * But the IBM Power6 Linux converts it to 0x00 47 33 ce 17 af 22 7f
+	     * and gets the correct value 20041683600089727.  It uses some special
+	     * algorithm.  We're going to define the macro and skip the test until
+	     * we can figure out how they do it. */
+	    if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
+		    s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
+		ret = 0;
+
+	    ull = (unsigned long)ld;
+	    memcpy(s2, &ull, 8);
+
+	    /* The unsigned long is the same as signed long. */
+	    if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
+		    s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
+		ret = 0;
+	}
+    }
+
+done:
+    exit(ret);
+}
+
+#endif
+
+#ifdef H5_LONG_TO_LDOUBLE_SPECIAL_TEST
+
+int main(void)
+{
+    long double         ld;
+    long                ll;
+    unsigned long       ull;
+    unsigned char       s[16];
+    int                 flag=0, ret=1;
+
+    /*Determine if long double has 16 byte in size, 11 bit exponent, and
+     *the bias is 0x3ff */
+    if(sizeof(long double) == 16) {
+	ld = 1.0L;
+	memcpy(s, &ld, 16);
+	if(s[0]==0x3f && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
+		s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00)
+	    flag = 1;
+    }
+
+    if(flag==1 && sizeof(long)==8) {
+	ll = 0x003fffffffffffffL;
+	ld = (long double)ll;
+	memcpy(s, &ld, 16);
+	/* The library converts the value to 0x434fffffffffffff8000000000000000.
+	 * In decimal it is 18014398509481982.000000, one value short of the original.
+	 * The IBM Power6 Linux converts it to 0x4350000000000000bff0000000000000.
+	 * The value is correct in decimal. It uses some special
+	 * algorithm.  We're going to define the macro and skip the test until
+	 * we can figure out how they do it. */
+	if(s[0]==0x43 && s[1]==0x50 && s[2]==0x00 && s[3]==0x00 &&
+		s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
+		s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
+		s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
+	    ret = 0;
+    }
+    if(flag==1 && sizeof(unsigned long)==8) {
+	ull = 0xffffffffffffffffUL;
+	ld = (long double)ull;
+	memcpy(s, &ld, 16);
+	/* Use a different value from signed long to test. The problem is the same
+	 * for both long and unsigned long. The value is 18446744073709551615.
+	 * The library converts the value to 0x43effffffffffffffe000000000000000.
+	 * In decimal it's 18446744073709548544.000000, very different from the original.
+	 * The IBM Power6 Linux converts it to 0x43f0000000000000bff0000000000000.
+	 * The value is correct in decimal. It uses some special
+	 * algorithm.  We're going to define the macro and skip the test until
+	 * we can figure out how they do it. */
+	if(s[0]==0x43 && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
+		s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
+		s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
+		s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
+	    ret = 0;
+    }
+done:
+    exit(ret);
+}
+
+#endif
+
 #ifdef H5_LDOUBLE_TO_LLONG_ACCURATE_TEST
 int main(void)
 {