HDFFV-10219 - fix for native in bin file and possible non-native in h5

15 files changed, 790 insertions, 228 deletions

diff --git a/MANIFEST b/MANIFEST
index 5018a12..b890352 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1275,22 +1275,16 @@
 ./tools/test/h5import/h5importtestutil.sh.in
 
 # testfiles for h5import
-./tools/test/h5import/testfiles/binfp64.conf
 ./tools/test/h5import/testfiles/binfp64.h5
-./tools/test/h5import/testfiles/binin16.conf
 ./tools/test/h5import/testfiles/binin16.h5
-./tools/test/h5import/testfiles/binin32.conf
 ./tools/test/h5import/testfiles/binin32.h5
-./tools/test/h5import/testfiles/binin8.conf
 ./tools/test/h5import/testfiles/binin8.h5
-./tools/test/h5import/testfiles/binin8w.conf
 ./tools/test/h5import/testfiles/binin8w.h5
-./tools/test/h5import/testfiles/binuin16.conf
 ./tools/test/h5import/testfiles/binuin16.h5
-./tools/test/h5import/testfiles/binuin32.conf
 ./tools/test/h5import/testfiles/binuin32.h5
 ./tools/test/h5import/testfiles/tall_fp32.ddl
 ./tools/test/h5import/testfiles/tall_i32.ddl
+./tools/test/h5import/testfiles/tintsattrs_u32.ddl
 ./tools/test/h5import/testfiles/textpfe.conf
 ./tools/test/h5import/testfiles/textpfe.h5
 ./tools/test/h5import/testfiles/textpfe64.txt
diff --git a/tools/src/h5import/CMakeLists.txt b/tools/src/h5import/CMakeLists.txt
index 9a61beb..eea0a17 100644
--- a/tools/src/h5import/CMakeLists.txt
+++ b/tools/src/h5import/CMakeLists.txt
@@ -13,7 +13,7 @@ add_executable (h5import ${HDF5_TOOLS_SRC_H5IMPORT_SOURCE_DIR}/h5import.c)
 TARGET_NAMING (h5import STATIC)
 TARGET_C_PROPERTIES (h5import STATIC " " " ")
 target_link_libraries (h5import  ${HDF5_TOOLS_LIB_TARGET} ${HDF5_LIB_TARGET})
-#set_target_properties (h5import PROPERTIES COMPILE_DEFINITIONS H5DEBUGIMPORT)
+set_target_properties (h5import PROPERTIES COMPILE_DEFINITIONS H5DEBUGIMPORT)
 set_target_properties (h5import PROPERTIES FOLDER tools)
 set_global_variable (HDF5_UTILS_TO_EXPORT "${HDF5_UTILS_TO_EXPORT};h5import")
 
diff --git a/tools/src/h5import/h5import.c b/tools/src/h5import/h5import.c
index 0f7be3d..c489e09 100644
--- a/tools/src/h5import/h5import.c
+++ b/tools/src/h5import/h5import.c
@@ -41,6 +41,7 @@ static int  parseDimensions(struct Input *in, char *strm);
 static int  getInputSize(struct Input *in, int ival);
 static int  getInputClass(struct Input *in, char * strm);
 static int  getInputClassType(struct Input *in, char * strm);
+static int  getInputByteOrder(struct Input *in, FILE *strm);
 static int  InputClassStrToInt(char *temp);
 static int  getRank(struct Input *in, FILE *strm);
 static int  getDimensionSizes(struct Input *in, FILE *strm);
@@ -497,7 +498,7 @@ static int readIntegerData(FILE *strm, struct Input *in)
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-#ifdef H5DEBUGIMPORT2
+#ifdef H5DEBUGIMPORT
                 printf("readIntegerData %d (0x%.8X)\n", *in08, *in08);
 #endif
             }
@@ -528,11 +529,11 @@ static int readIntegerData(FILE *strm, struct Input *in)
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-                if (in->outputByteOrder)
-                    *in16 = temp16;
-                else
+                if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder))
                     *in16 = swap_int16(temp16);
-#ifdef H5DEBUGIMPORT2
+                else
+                    *in16 = temp16;
+#ifdef H5DEBUGIMPORT
                 printf("readIntegerData %d (0x%.8X)\n", *in16, temp16);
 #endif
             }
@@ -562,10 +563,10 @@ static int readIntegerData(FILE *strm, struct Input *in)
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-                if (in->outputByteOrder)
-                    *in32 = temp32;
-                else
+                if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder))
                     *in32 = swap_int32(temp32);
+                else
+                    *in32 = temp32;
 #ifdef H5DEBUGIMPORT
                 printf("readIntegerData %d (0x%.8X = 0x%.8X)\n", *in32, *in32, temp32);
 #endif
@@ -598,11 +599,11 @@ static int readIntegerData(FILE *strm, struct Input *in)
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-                if (in->outputByteOrder)
-                    *in64 = temp64;
-                else
+                if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder))
                     *in64 = swap_int64(temp64);
-#ifdef H5DEBUGIMPORT2
+                else
+                    *in64 = temp64;
+#ifdef H5DEBUGIMPORT
                 printf("readIntegerData %d (0x%.8X)\n", *in64, temp64);
 #endif
             }
@@ -692,10 +693,13 @@ static int readUIntegerData(FILE *strm, struct Input *in)
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-                if (in->outputByteOrder)
-                    *in16 = temp16;
-                else
+                if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder))
                     *in16 = swap_uint16(temp16);
+                else
+                    *in16 = temp16;
+#ifdef H5DEBUGIMPORT
+                printf("readUIntegerData %d (0x%.4X = 0x%.4X)\n", *in16, *in16, temp16);
+#endif
             }
             break;
 
@@ -723,10 +727,13 @@ static int readUIntegerData(FILE *strm, struct Input *in)
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-                if (in->outputByteOrder)
-                    *in32 = temp32;
-                else
+                if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder))
                     *in32 = swap_uint32(temp32);
+                else
+                    *in32 = temp32;
+#ifdef H5DEBUGIMPORT
+                printf("readUIntegerData %d (0x%.8X = 0x%.8X)\n", *in32, *in32, temp32);
+#endif
             }
             break;
 
@@ -756,10 +763,13 @@ static int readUIntegerData(FILE *strm, struct Input *in)
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-                if (in->outputByteOrder)
-                    *in64 = temp64;
-                else
+                if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder))
                     *in64 = swap_uint64(temp64);
+                else
+                    *in64 = temp64;
+#ifdef H5DEBUGIMPORT
+                printf("readUIntegerData %ld (0x%.8X = 0x%.8X)\n", *in64, *in64, temp64);
+#endif
             }
             break;
 
@@ -831,12 +841,12 @@ static int readFloatData(FILE *strm, struct Input *in)
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-                if (in->outputByteOrder)
-                    *bfp32 = temp32;
-                else
+                if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder))
                     *bfp32 = swap_uint32(temp32);
+                else
+                    *bfp32 = temp32;
 #ifdef H5DEBUGIMPORT
-                printf("readFloatData %f (0x%.8X = 0x%.8X)\n", *bfp32, *bfp32, temp32);
+                printf("readFloatData %ld (0x%.8X = 0x%.8X)\n", *bfp32, *bfp32, temp32);
 #endif
             }
             break;
@@ -881,12 +891,12 @@ static int readFloatData(FILE *strm, struct Input *in)
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-                if (in->outputByteOrder)
-                    *bfp64 = temp64;
-                else
+                if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder))
                     *bfp64 = swap_uint64(temp64);
-#ifdef H5DEBUGIMPORT2
-                printf("readFloatData %lf (0x%.8X)\n", fp64, temp64);
+                else
+                    *bfp64 = temp64;
+#ifdef H5DEBUGIMPORT
+                printf("readFloatData %ld (0x%.16lX)\n", *bfp64, temp64);
 #endif
             }
             break;
@@ -1353,7 +1363,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
     int         retval = -1;
 
     const char *err1 = "Unable to open the configuration file:  %s for reading.\n";
-    const char *err2 = "Unknown keyword in configuration file: %s\n";
+    const char *err2 = "Unknown keyword: %s in configuration file: %s\n";
     const char *err3a = "PATH keyword appears twice in %s.\n";
     const char *err3b = "Error in parsing the path information from %s.\n";
     const char *err4a = "INPUT-CLASS keyword appears twice in %s.\n";
@@ -1373,6 +1383,9 @@ static int processConfigurationFile(char *infile, struct Input *in)
     const char *err10b = "Error in retrieving the output architecture from %s.\n";
     const char *err11a = "OUTPUT-BYTE-ORDER keyword appears twice in %s.\n";
     const char *err11b = "Error in retrieving the output byte order from %s.\n";
+    const char *err11c = "INPUT-BYTE-ORDER keyword appears twice in %s.\n";
+    const char *err11d = "Error in retrieving the input byte order from %s.\n";
+    const char *err11e = "Invalid value for output byte-order.\n";
     const char *err12a = "CHUNKED-DIMENSION-SIZES keyword appears twice in %s.\n";
     const char *err12b = "CHUNKED-DIMENSION-SIZES cannot appear before DIMENSION-SIZES are provided.\n";
     const char *err12c = "Error in retrieving the chunked dimension sizes from %s.\n";
@@ -1396,6 +1409,26 @@ static int processConfigurationFile(char *infile, struct Input *in)
      process the output file according to the options
      */
 
+    /* Initialize machine endian */
+    volatile uint32_t ibyte=0x01234567;
+    /* 0 for big endian, 1 for little endian. */
+    if ((*((uint8_t*)(&ibyte))) == 0x67) {
+        if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
+            (void) HDfprintf(stderr, "%s", err11e);
+            return (-1);
+        }
+    }
+    else {
+        if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
+            (void) HDfprintf(stderr, "%s", err11e);
+            return (-1);
+        }
+    }
+    in->inputByteOrder = kindex;
+#ifdef H5DEBUGIMPORT
+    printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+#endif
+
     if ((strm = HDfopen(infile, "r")) == NULL) {
         (void) HDfprintf(stderr, err1, infile);
         goto error;
@@ -1631,15 +1664,15 @@ static int processConfigurationFile(char *infile, struct Input *in)
                             goto error;
                         }
 #ifdef H5DEBUGIMPORT
-                        printf("h5dump DATASPACE SIMPLE %d rank\n", in->rank);
+                        printf("h5dump DATASPACE SIMPLE %ld rank\n", in->rank);
 #endif
                         for (i = 0; i < in->rank; i++) {
                             in->sizeOfDimension[i] = temp_dims[i];
                         }
 #ifdef H5DEBUGIMPORT
-                        printf("h5dump DATASPACE SIMPLE dims:", in->rank);
+                        printf("h5dump DATASPACE SIMPLE dims[%ld]:", in->rank);
                         for (pndx = 0; pndx < in->rank; pndx++) {
-                            printf(" %d", in->sizeOfDimension[pndx]);
+                            printf(" %ld", in->sizeOfDimension[pndx]);
                         }
                         printf("\n");
 #endif
@@ -1712,9 +1745,9 @@ static int processConfigurationFile(char *infile, struct Input *in)
                                 }
                             } /* while (get_next_dim) */
 #ifdef H5DEBUGIMPORT
-                            printf("h5dump DATASPACE SIMPLE maxdims:", in->rank);
+                            printf("h5dump DATASPACE SIMPLE maxdims[%ld]:", in->rank);
                             for (pndx = 0; pndx < in->rank; pndx++) {
-                                printf(" %d", in->maxsizeOfDimension[pndx]);
+                                printf(" %ld", in->maxsizeOfDimension[pndx]);
                             }
                             printf("\n");
                             printf("h5dump DATASPACE SIMPLE get max dim finished\n");
@@ -1799,9 +1832,9 @@ static int processConfigurationFile(char *infile, struct Input *in)
                             }
                         } /* while (get_next_dim) */
 #ifdef H5DEBUGIMPORT
-                        printf("h5dump STORAGE_LAYOUT CHUNKED dims:", in->rank);
+                        printf("h5dump STORAGE_LAYOUT CHUNKED dims [%ld]:", in->rank);
                         for (pndx = 0; pndx < in->rank; pndx++) {
-                            printf(" %d", in->sizeOfChunk[pndx]);
+                            printf(" %ld", in->sizeOfChunk[pndx]);
                         }
                         printf("\n");
 #endif
@@ -1927,7 +1960,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
                 printf("h5dump SUBSET key\n");
 #endif
                 if (fscanf(strm, "%s", temp) != 1) { /* start bracket */
-                    (void) HDfprintf(stderr, err6b, infile);
+                    (void) HDfprintf(stderr, err20, infile);
                     goto error;
                 }
 #ifdef H5DEBUGIMPORT
@@ -1990,7 +2023,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
 #ifdef H5DEBUGIMPORT
                             printf("h5dump SUBSET COUNT dims: [%d]", in->rank);
                             for (pndx = 0; pndx < in->rank; pndx++) {
-                                printf(" %d", in->sizeOfDimension[pndx]);
+                                printf(" %ld", in->sizeOfDimension[pndx]);
                             }
                             printf("\n");
 #endif
@@ -2046,7 +2079,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
 #ifdef H5DEBUGIMPORT
                             printf("h5dump SUBSET BLOCK dims: [%d]", in->rank);
                             for (pndx = 0; pndx < in->rank; pndx++) {
-                                printf(" %d", in->sizeOfDimension[pndx]);
+                                printf(" %ld", in->sizeOfDimension[pndx]);
                             }
                             printf("\n");
 #endif
@@ -2082,6 +2115,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
         printf("\n");
         printf("h5dump inputClass=%d\n", in->inputClass);
         printf("h5dump inputSize=%d\n", in->inputSize);
+        printf("h5dump inputByteOrder=%d\n", in->inputByteOrder);
         printf("h5dump rank=%d\n", in->rank);
         printf("h5dump outputClass=%d\n", in->outputClass);
         printf("h5dump outputSize=%d\n", in->outputSize);
@@ -2092,7 +2126,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
         printf("h5dump externFilename=%s\n", in->externFilename);
         printf("h5dump sizeOfDimensions:\n");
         for (pndx = 0; pndx < in->rank; pndx++) {
-            printf("  %d\n", in->sizeOfDimension[pndx]);
+            printf("  %ld\n", in->sizeOfDimension[pndx]);
         }
 #endif
     }
@@ -2102,7 +2136,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
 #endif
         while (scanret == 1) {
             if ((kindex = mapKeywordToIndex(key)) == -1) {
-                (void) HDfprintf(stderr, err2, infile);
+                (void) HDfprintf(stderr, err2, key, infile);
                 goto error;
             }
             switch (kindex) {
@@ -2337,6 +2371,19 @@ static int processConfigurationFile(char *infile, struct Input *in)
                 in->configOptionVector[EXTEND] = 1;
                 break;
 
+            case 14: /* INPUT-BYTE-ORDER */
+                if (in->configOptionVector[INPUT_B_ORDER] == 1) {
+                    (void) HDfprintf(stderr, err11c, infile);
+                    goto error;
+                }
+
+                if (getInputByteOrder(in, strm) == -1) {
+                    (void) HDfprintf(stderr, err11d, infile);
+                    goto error;
+                }
+                in->configOptionVector[INPUT_B_ORDER] = 1;
+                break;
+
             default:
                 break;
             }
@@ -2577,7 +2624,7 @@ static int getInputClassType(struct Input *in, char * buffer)
     int         kindex = -1;
     const char *err1 = "Invalid value for input class.\n";
     const char *err2 = "Invalid value for output architecture.\n";
-    const char *err3 = "Invalid value for output byte-order.\n";
+    const char *err3 = "Invalid value for input byte-order.\n";
 
     if (!HDstrcmp(buffer, "H5T_STD_I8BE")) {
         in->inputSize = 8;
@@ -2594,6 +2641,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2612,6 +2663,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2630,6 +2685,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2648,6 +2707,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2666,6 +2729,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2684,6 +2751,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2702,6 +2773,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2720,6 +2795,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2738,6 +2817,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2756,6 +2839,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2774,6 +2861,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2792,6 +2883,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2810,6 +2905,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2828,6 +2927,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2846,6 +2949,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2864,6 +2971,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -3002,6 +3113,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 3;
     }
@@ -3020,6 +3135,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 3;
     }
@@ -3038,6 +3157,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 3;
     }
@@ -3056,6 +3179,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 3;
     }
@@ -3129,6 +3256,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3145,6 +3276,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3161,6 +3296,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3177,6 +3316,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3193,6 +3336,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3209,6 +3356,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3225,6 +3376,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3241,6 +3396,10 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+//        in->inputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3313,6 +3472,27 @@ static int getInputSize(struct Input *in, int ival)
     return (-1);
 }
 
+static int getInputByteOrder(struct Input *in, FILE *strm)
+{
+    char        temp[255];
+    int         kindex;
+    const char *err1 = "Unable to get 'string' value.\n";
+    const char *err2 = "Invalid value for input byte-order.\n";
+
+    if (fscanf(strm, "%s", temp) != 1) {
+        (void) HDfprintf(stderr, "%s", err1);
+        return (-1);
+    }
+
+    if ((kindex = OutputByteOrderStrToInt(temp)) == -1) {
+        (void) HDfprintf(stderr, "%s", err2);
+        return (-1);
+    }
+
+    in->inputByteOrder = kindex;
+    return (0);
+}
+
 static int getRank(struct Input *in, FILE *strm)
 {
     int         ival;
@@ -3578,6 +3758,7 @@ void setDefaultValues(struct Input *in, int count)
     in->inputSize = 32;
     in->outputClass = 1; /* FP */
     in->outputSize = 32;
+    in->inputByteOrder = -1; /* use default    */
     in->rank = 0;
     in->path.count = 1;
 
@@ -3950,85 +4131,433 @@ hid_t createInputDataType(struct Input *in)
 {
     hid_t       new_type = (-1);
     const char *err1 = "Invalid value for input class.\n";
-    const char *err2 = "Invalid value for output size.\n";
+    const char *err2 = "Invalid value for input size.\n";
+    const char *err3 = "Invalid value for input byte order.\n";
+    const char *err4 = "Invalid value for output architecture.\n";
+    const char *err5 = "STD not supported for float.\n";
+    const char *err6 = "IEEE not supported for INT.\n";
 
-    switch (in->inputClass) {
-    case 0:
-    case 4:
-        switch (in->inputSize) {
-        case 8:
-            new_type = H5Tcopy(H5T_NATIVE_CHAR);
-            break;
+    if (in->h5dumpInput) {
+        switch (in->inputClass) {
+        case 4:
+            switch (in->outputArchitecture) {
+            case 0: /* NATIVE */
+                switch (in->inputSize) {
+                case 8:
+                    new_type = H5Tcopy(H5T_NATIVE_CHAR);
+                    break;
 
-        case 16:
-            new_type = H5Tcopy(H5T_NATIVE_SHORT);
-            break;
+                case 16:
+                    new_type = H5Tcopy(H5T_NATIVE_SHORT);
+                    break;
 
-        case 32:
-            new_type = H5Tcopy(H5T_NATIVE_INT);
-            break;
+                case 32:
+                    new_type = H5Tcopy(H5T_NATIVE_INT);
+                    break;
 
-        case 64:
-            new_type = H5Tcopy(H5T_NATIVE_LLONG);
+                case 64:
+                    new_type = H5Tcopy(H5T_NATIVE_LLONG);
+                    break;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err2);
+                    return (-1);
+                }
+                switch (in->inputByteOrder) {
+                case -1: /* default */
+                    break;
+                case 0:
+                    H5Tset_order(new_type, H5T_ORDER_BE);
+                    break;
+
+                case 1:
+                    H5Tset_order(new_type, H5T_ORDER_LE);
+                    break;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err3);
+                    return (-1);
+                }
+                break;
+
+            case 1: /* STD */
+                switch (in->inputSize) {
+                case 8:
+                    switch (in->inputByteOrder) {
+                    case -1:
+                    case 0:
+                        new_type = H5Tcopy(H5T_STD_I8BE);
+                        break;
+
+                    case 1:
+                        new_type = H5Tcopy(H5T_STD_I8LE);
+                        break;
+
+                    default:
+                        (void) HDfprintf(stderr, "%s", err3);
+                        return (-1);
+                    }
+                    break;
+
+                case 16:
+                    switch (in->inputByteOrder) {
+                    case -1:
+                    case 0:
+                        new_type = H5Tcopy(H5T_STD_I16BE);
+                        break;
+
+                    case 1:
+                        new_type = H5Tcopy(H5T_STD_I16LE);
+                        break;
+
+                    default:
+                        (void) HDfprintf(stderr, "%s", err3);
+                        return (-1);
+                    }
+                    break;
+
+                case 32:
+                    switch (in->inputByteOrder) {
+                    case -1:
+                    case 0:
+                        new_type = H5Tcopy(H5T_STD_I32BE);
+                        break;
+
+                    case 1:
+                        new_type = H5Tcopy(H5T_STD_I32LE);
+                        break;
+
+                    default:
+                        (void) HDfprintf(stderr, "%s", err3);
+                        return (-1);
+                    }
+                    break;
+
+                case 64:
+                    switch (in->inputByteOrder) {
+                    case -1:
+                    case 0:
+                        new_type = H5Tcopy(H5T_STD_I64BE);
+                        break;
+
+                    case 1:
+                        new_type = H5Tcopy(H5T_STD_I64LE);
+                        break;
+
+                    default:
+                        (void) HDfprintf(stderr, "%s", err3);
+                        return (-1);
+                    }
+                    break;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err2);
+                    return (-1);
+                }
+                break;
+
+            default:
+                (void) HDfprintf(stderr, "%s", err4);
+                return (-1);
+            }
             break;
 
-        default:
-            (void) HDfprintf(stderr, "%s", err2);
-            return (-1);
-        }
-        break;
+        case 3:
+            switch (in->outputArchitecture) {
+            case 0:
+                switch (in->inputSize) {
+                case 32:
+                    new_type = H5Tcopy(H5T_NATIVE_FLOAT);
+                    break;
 
-    case 1:
-    case 2:
-    case 3:
-        switch (in->inputSize) {
-        case 32:
-            new_type = H5Tcopy(H5T_NATIVE_FLOAT);
+                case 64:
+                    new_type = H5Tcopy(H5T_NATIVE_DOUBLE);
+                    break;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err2);
+                    return (-1);
+                }
+                switch (in->inputByteOrder) {
+                case -1: /* DEFAULT */
+                    break;
+                case 0:
+                    H5Tset_order(new_type, H5T_ORDER_BE);
+                    break;
+
+                case 1:
+                    H5Tset_order(new_type, H5T_ORDER_LE);
+                    break;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err3);
+                    return (-1);
+                }
+                break;
+
+            case 1:
+                (void) HDfprintf(stderr, "%s", err5);
+                return (-1);
+
+            case 2:
+                switch (in->inputSize) {
+                case 32:
+                    switch (in->inputByteOrder) {
+                    case -1:
+                    case 0:
+                        new_type = H5Tcopy(H5T_IEEE_F32BE);
+                        break;
+
+                    case 1:
+                        new_type = H5Tcopy(H5T_IEEE_F32LE);
+                        break;
+
+                    default:
+                        (void) HDfprintf(stderr, "%s", err3);
+                        return (-1);
+                    }
+                    break;
+
+                case 64:
+                    switch (in->inputByteOrder) {
+                    case -1:
+                    case 0:
+                        new_type = H5Tcopy(H5T_IEEE_F64BE);
+                        break;
+
+                    case 1:
+                        new_type = H5Tcopy(H5T_IEEE_F64LE);
+                        break;
+
+                    default:
+                        (void) HDfprintf(stderr, "%s", err3);
+                        return (-1);
+                    }
+                    break;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err2);
+                    return (-1);
+                }
+                break;
+
+            default:
+                (void) HDfprintf(stderr, "%s", err4);
+                return (-1);
+            }
             break;
 
-        case 64:
-            new_type = H5Tcopy(H5T_NATIVE_DOUBLE);
+        case 7:
+            switch (in->outputArchitecture) {
+            case 0:
+                switch (in->inputSize) {
+                case 8:
+                    new_type = H5Tcopy(H5T_NATIVE_UCHAR);
+                    break;
+
+                case 16:
+                    new_type = H5Tcopy(H5T_NATIVE_USHORT);
+                    break;
+
+                case 32:
+                    new_type = H5Tcopy(H5T_NATIVE_UINT);
+                    break;
+
+                case 64:
+                    new_type = H5Tcopy(H5T_NATIVE_ULLONG);
+                    break;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err2);
+                    return (-1);
+                }
+                switch (in->inputByteOrder) {
+                case -1: /* Default */
+                    break;
+                case 0:
+                    H5Tset_order(new_type, H5T_ORDER_BE);
+                    break;
+
+                case 1:
+                    H5Tset_order(new_type, H5T_ORDER_LE);
+                    break;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err3);
+                    return (-1);
+                }
+                break;
+
+            case 1:
+                switch (in->inputSize) {
+                case 8:
+                    switch (in->inputByteOrder) {
+                    case -1:
+                    case 0:
+                        new_type = H5Tcopy(H5T_STD_U8BE);
+                        break;
+
+                    case 1:
+                        new_type = H5Tcopy(H5T_STD_U8LE);
+                        break;
+
+                    default:
+                        (void) HDfprintf(stderr, "%s", err3);
+                        return (-1);
+                    }
+                    break;
+
+                case 16:
+                    switch (in->inputByteOrder) {
+                    case -1:
+                    case 0:
+                        new_type = H5Tcopy(H5T_STD_U16BE);
+                        break;
+
+                    case 1:
+                        new_type = H5Tcopy(H5T_STD_U16LE);
+                        break;
+
+                    default:
+                        (void) HDfprintf(stderr, "%s", err3);
+                        return (-1);
+                    }
+                    break;
+
+                case 32:
+                    switch (in->inputByteOrder) {
+                    case -1:
+                    case 0:
+                        new_type = H5Tcopy(H5T_STD_U32BE);
+                        break;
+
+                    case 1:
+                        new_type = H5Tcopy(H5T_STD_U32LE);
+                        break;
+
+                    default:
+                        (void) HDfprintf(stderr, "%s", err3);
+                        return (-1);
+                    }
+                    break;
+
+                case 64:
+                    switch (in->inputByteOrder) {
+                    case -1:
+                    case 0:
+                        new_type = H5Tcopy(H5T_STD_U64BE);
+                        break;
+
+                    case 1:
+                        new_type = H5Tcopy(H5T_STD_U64LE);
+                        break;
+
+                    default:
+                        (void) HDfprintf(stderr, "%s", err3);
+                        return (-1);
+                    }
+                    break;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err2);
+                    return (-1);
+                }
+                break;
+
+            case 2:
+                (void) HDfprintf(stderr, "%s", err6);
+                return (-1);
+
+            default:
+                (void) HDfprintf(stderr, "%s", err4);
+                return (-1);
+            }
             break;
 
         default:
-            (void) HDfprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
-        break;
+    }
+    else {
+        switch (in->inputClass) {
+        case 0:
+        case 4:
+            switch (in->inputSize) {
+            case 8:
+                new_type = H5Tcopy(H5T_NATIVE_CHAR);
+                break;
 
-    case 5:
-        (void) HDfprintf(stderr, "%s", err1);
-        return (-1);
-        break;
+            case 16:
+                new_type = H5Tcopy(H5T_NATIVE_SHORT);
+                break;
+
+            case 32:
+                new_type = H5Tcopy(H5T_NATIVE_INT);
+                break;
+
+            case 64:
+                new_type = H5Tcopy(H5T_NATIVE_LLONG);
+                break;
 
-    case 6:
-    case 7:
-        switch (in->inputSize) {
-        case 8:
-            new_type = H5Tcopy(H5T_NATIVE_UCHAR);
+            default:
+                (void) HDfprintf(stderr, "%s", err2);
+                return (-1);
+            }
             break;
 
-        case 16:
-            new_type = H5Tcopy(H5T_NATIVE_USHORT);
+        case 1:
+        case 2:
+        case 3:
+            switch (in->inputSize) {
+            case 32:
+                new_type = H5Tcopy(H5T_NATIVE_FLOAT);
+                break;
+
+            case 64:
+                new_type = H5Tcopy(H5T_NATIVE_DOUBLE);
+                break;
+
+            default:
+                (void) HDfprintf(stderr, "%s", err2);
+                return (-1);
+            }
             break;
 
-        case 32:
-            new_type = H5Tcopy(H5T_NATIVE_UINT);
+        case 5:
+            (void) HDfprintf(stderr, "%s", err1);
+            return (-1);
             break;
 
-        case 64:
-            new_type = H5Tcopy(H5T_NATIVE_ULLONG);
+        case 6:
+        case 7:
+            switch (in->inputSize) {
+            case 8:
+                new_type = H5Tcopy(H5T_NATIVE_UCHAR);
+                break;
+
+            case 16:
+                new_type = H5Tcopy(H5T_NATIVE_USHORT);
+                break;
+
+            case 32:
+                new_type = H5Tcopy(H5T_NATIVE_UINT);
+                break;
+
+            case 64:
+                new_type = H5Tcopy(H5T_NATIVE_ULLONG);
+                break;
+
+            default:
+                (void) HDfprintf(stderr, "%s", err2);
+                return (-1);
+            }
             break;
 
         default:
-            (void) HDfprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
-        break;
-
-    default:
-        (void) HDfprintf(stderr, "%s", err1);
-        return (-1);
     }
     return new_type;
 }
@@ -4117,7 +4646,7 @@ static int process(struct Options *opt)
             intype = createInputDataType(in);
             outtype = createOutputDataType(in);
 #ifdef H5DEBUGIMPORT
-            printf("process intype %d outtype %d\n", intype, outtype);
+            printf("process intype %ld outtype %ld\n", intype, outtype);
 #endif
 
             /* create property list */
@@ -4416,6 +4945,7 @@ void help(char *name)
     (void) HDfprintf(stdout, "\t    PATH\n");
     (void) HDfprintf(stdout, "\t    INPUT-CLASS\n");
     (void) HDfprintf(stdout, "\t    INPUT-SIZE\n");
+    (void) HDfprintf(stdout, "\t    INPUT-BYTE-ORDER\n");
     (void) HDfprintf(stdout, "\t    RANK\n");
     (void) HDfprintf(stdout, "\t    DIMENSION-SIZES\n");
     (void) HDfprintf(stdout, "\t    OUTPUT-CLASS\n");
diff --git a/tools/src/h5import/h5import.h b/tools/src/h5import/h5import.h
index c69a542..b27b944 100644
--- a/tools/src/h5import/h5import.h
+++ b/tools/src/h5import/h5import.h
@@ -37,7 +37,7 @@
 
 #define MAX_GROUPS_IN_PATH  20
 #define MAX_PATH_NAME_LENGTH 255
-#define NUM_KEYS 14
+#define NUM_KEYS 15
 #define MIN_NUM_DIMENSION  1
 #define MAX_NUM_DIMENSION  32
 #define BASE_10 10
@@ -56,6 +56,7 @@
 #define COMPRESS_PARAM   11
 #define EXTERNALSTORE    12
 #define EXTEND           13
+#define INPUT_B_ORDER    14
 
 /* data types */
 #define H5DT_INT8      signed char
@@ -82,6 +83,7 @@ struct Input
     struct path_info path;
     int inputClass;
     int inputSize;
+    int inputByteOrder;
     int rank;
     hsize_t* sizeOfDimension;
     int outputClass;
@@ -126,7 +128,8 @@ char keytable[NUM_KEYS][30] = {
         "COMPRESSION-TYPE",
         "COMPRESSION-PARAM",
         "EXTERNAL-STORAGE",
-        "MAXIMUM-DIMENSIONS"
+        "MAXIMUM-DIMENSIONS",
+        "INPUT-BYTE-ORDER"
 };
 
 static int  state_table[15][8] =
diff --git a/tools/test/h5import/CMakeTests.cmake b/tools/test/h5import/CMakeTests.cmake
index 89685fa..009434f 100644
--- a/tools/test/h5import/CMakeTests.cmake
+++ b/tools/test/h5import/CMakeTests.cmake
@@ -17,13 +17,6 @@
 ##############################################################################
 
   set (HDF5_REFERENCE_CONF_FILES
-      binfp64.conf
-      binin8.conf
-      binin8w.conf
-      binin16.conf
-      binin32.conf
-      binuin16.conf
-      binuin32.conf
       txtfp32.conf
       txtfp64.conf
       txtin8.conf
@@ -75,6 +68,7 @@
   )
   set (HDF5_TOOLS_TEST_FILES
       tall.h5
+      tintsattrs.h5
   )
 
   file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
@@ -176,7 +170,7 @@
             NAME H5IMPORT-DUMP-${testname}-H5DMP
             COMMAND "${CMAKE_COMMAND}"
                 -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
-                -D "TEST_ARGS:STRING=-p;-d;${datasetname};-o;d${testfile}.bin;-b;testfiles/${testfile}"
+                -D "TEST_ARGS:STRING=-p;-d;${datasetname};-o;d${testfile}.bin;-b;FILE;testfiles/${testfile}"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
                 -D "TEST_OUTPUT=d${testfile}.dmp"
                 -D "TEST_EXPECT=0"
@@ -489,12 +483,19 @@
       COMMAND    ${CMAKE_COMMAND}
           -E remove
           binfp64.bin
+          binfp64.conf
           binin8.bin
+          binin8.conf
           binin8w.bin
+          binin8w.conf
           binin16.bin
+          binin16.conf
           binin32.bin
+          binin32.conf
           binuin16.bin
+          binuin16.conf
           binuin32.bin
+          binuin32.conf
   )
   if (NOT "${last_test}" STREQUAL "")
     set_tests_properties (H5IMPORT-h5importtest-clear-objects PROPERTIES DEPENDS ${last_test})
@@ -526,7 +527,7 @@
   ADD_H5_TEST (ASCII_F64 testfiles/txtfp64.txt testfiles/txtfp64.conf txtfp64.h5)
 
   # ----- TESTING "BINARY F64 - rank 3 - Output LE+CHUNKED+Extended+Compressed "
-  ADD_H5_TEST (BINARY_F64 binfp64.bin testfiles/binfp64.conf binfp64.h5)
+  ADD_H5_TEST (BINARY_F64 binfp64.bin binfp64.conf binfp64.h5)
   if (NOT USE_FILTER_DEFLATE)
     ADD_H5_SKIP_DUMPTEST (BINARY_F64 "/fp/bin/64-bit" binfp64.h5 BINARY)
   else ()
@@ -534,7 +535,7 @@
   endif ()
 
   # ----- TESTING "BINARY I8 - rank 3 - Output I16LE + Chunked+Extended+Compressed "
-  ADD_H5_TEST (BINARY_I8 binin8.bin testfiles/binin8.conf binin8.h5)
+  ADD_H5_TEST (BINARY_I8 binin8.bin binin8.conf binin8.h5)
   if (NOT USE_FILTER_DEFLATE)
     ADD_H5_SKIP_DUMPTEST (BINARY_I8 "/int/bin/8-bit" binin8.h5 BINARY)
   else ()
@@ -542,19 +543,19 @@
   endif ()
 
   # ----- TESTING "BINARY I16 - rank 3 - Output order LE + CHUNKED + extended "
-  ADD_H5_TEST (BINARY_I16 binin16.bin testfiles/binin16.conf binin16.h5)
+  ADD_H5_TEST (BINARY_I16 binin16.bin binin16.conf binin16.h5)
   ADD_H5_DUMPTEST (BINARY_I16 "/int/bin/16-bit" binin16.h5 BINARY)
 
   # ----- TESTING "BINARY I32 - rank 3 - Output BE + CHUNKED "
-  ADD_H5_TEST (BINARY_I32 binin32.bin testfiles/binin32.conf binin32.h5)
+  ADD_H5_TEST (BINARY_I32 binin32.bin binin32.conf binin32.h5)
   ADD_H5_DUMPTEST (BINARY_I32 "/int/bin/32-bit" binin32.h5 BINARY)
 
   # ----- TESTING "BINARY UI16 - rank 3 - Output byte BE + CHUNKED "
-  ADD_H5_TEST (BINARY_UI16 binuin16.bin testfiles/binuin16.conf binuin16.h5)
+  ADD_H5_TEST (BINARY_UI16 binuin16.bin binuin16.conf binuin16.h5)
   ADD_H5_DUMPTEST (BINARY_UI16 "/int/buin/16-bit" binuin16.h5 BINARY)
 
   # ----- TESTING "BINARY UI32 - rank 3 - Output LE "
-  ADD_H5_TEST (BINARY_UI32 binuin32.bin testfiles/binuin32.conf binuin32.h5)
+  ADD_H5_TEST (BINARY_UI32 binuin32.bin binuin32.conf binuin32.h5)
   ADD_H5_DUMPTEST (BINARY_UI32 "/int/buin/32-bit" binuin32.h5 BINARY)
 
   # ----- TESTING "STR"
@@ -562,7 +563,7 @@
   ADD_H5_DUMPTEST (STR "/mytext/data" txtstr.h5)
 
   # ----- TESTING "BINARY I8 CR LF EOF"
-  ADD_H5_TEST (BINARY_I8_EOF binin8w.bin testfiles/binin8w.conf binin8w.h5)
+  ADD_H5_TEST (BINARY_I8_EOF binin8w.bin binin8w.conf binin8w.h5)
   ADD_H5_DUMPTEST (BINARY_I8_EOF "/dataset0" binin8w.h5 BINARY)
 
   # ----- TESTING "ASCII F64 - rank 1 - INPUT-CLASS TEXTFPE "
@@ -571,4 +572,5 @@
   # ----- TESTING "Binary Subset "
   ADD_H5_DUMPSUBTEST (tall_fp32 tall.h5 /g2/dset2.2 --start=1,1 --stride=2,3 --count=1,2 --block=1,1)
   ADD_H5_DUMPSUBTEST (tall_i32 tall.h5 /g1/g1.1/dset1.1.1 --start=1,1 --stride=2,3 --count=3,2 --block=1,1)
+  ADD_H5_DUMPSUBTEST (tintsattrs_u32 tintsattrs.h5 /DU32BITS --start=1,1 --stride=2,3 --count=3,2 --block=1,1)
 
diff --git a/tools/test/h5import/h5importtest.c b/tools/test/h5import/h5importtest.c
index 135b8e4..00ae2e7 100644
--- a/tools/test/h5import/h5importtest.c
+++ b/tools/test/h5import/h5importtest.c
@@ -25,7 +25,7 @@
  *      h5importtest
  *
  * Description:
- *      This program creates that can be
+ *      This program creates files that can be
  *      used to test the h5import program.
  *
  */
@@ -36,6 +36,7 @@ main(void)
     int       nrow = 3, ncol = 4, npln = 5;
     int       i, j, k;
     FILE      *sp;
+    char      machine_order[3] = {0, 0, 0};
 
     float     row4[3], col4[4], pln4[5];
     float     rowo4 = 11.0F, colo4 = 21.0F, plno4 = 51.0F;
@@ -67,6 +68,14 @@ main(void)
     double    rowo8 = 11.0F, colo8 = 21.0F, plno8 = 51.0F;
     double    rowi8 = 1.0F, coli8 = 2.0F, plni8 = 5.0F;
 
+    /* Initialize machine endian */
+    volatile uint32_t ibyte=0x01234567;
+    /* 0 for big endian, 1 for little endian. */
+    if ((*((uint8_t*)(&ibyte))) == 0x67)
+        strncpy(machine_order, "LE", 2);
+    else
+        strncpy(machine_order, "BE", 2);
+
 
     /*
     * initialize the row, column, and plane vectors
@@ -217,7 +226,7 @@ main(void)
 #endif
 
  /*-------------------------------------------------------------------------
-  * TOOLTEST binin32.bin -c $srcdir/testfiles/binin32.conf -o binin32.h5
+  * TOOLTEST binin32.bin -c binin32.conf -o binin32.h5
   *-------------------------------------------------------------------------
   */
 
@@ -234,8 +243,21 @@ main(void)
     }
     (void) HDfclose(sp);
 
+    sp = HDfopen("binin32.conf", "w");
+    (void) fprintf(sp, "PATH /int/bin/32-bit\n");
+    (void) fprintf(sp, "INPUT-CLASS IN\n");
+    (void) fprintf(sp, "INPUT-SIZE    32\n");
+    (void) fprintf(sp, "INPUT-BYTE-ORDER %s\n", machine_order);
+    (void) fprintf(sp, "RANK 3\n");
+    (void) fprintf(sp, "OUTPUT-ARCHITECTURE STD\n");
+    (void) fprintf(sp, "OUTPUT-BYTE-ORDER BE\n");
+    (void) fprintf(sp, "DIMENSION-SIZES 5 3 4\n");
+    (void) fprintf(sp, "CHUNKED-DIMENSION-SIZES 1 2 1\n");
+    (void) fprintf(sp, "\n");
+    (void) HDfclose(sp);
+
  /*-------------------------------------------------------------------------
-  * TOOLTEST binuin32.bin -c $srcdir/testfiles/binuin32.conf -o binuin32.h5
+  * TOOLTEST binuin32.bin -c binuin32.conf -o binuin32.h5
   *-------------------------------------------------------------------------
   */
 
@@ -252,11 +274,20 @@ main(void)
     }
     (void) HDfclose(sp);
 
-
-
+    sp = HDfopen("binuin32.conf", "w");
+    (void) fprintf(sp, "PATH /int/buin/32-bit\n");
+    (void) fprintf(sp, "INPUT-CLASS UIN\n");
+    (void) fprintf(sp, "INPUT-SIZE    32\n");
+    (void) fprintf(sp, "INPUT-BYTE-ORDER %s\n", machine_order);
+    (void) fprintf(sp, "RANK 3\n");
+    (void) fprintf(sp, "OUTPUT-ARCHITECTURE STD\n");
+    (void) fprintf(sp, "OUTPUT-BYTE-ORDER LE\n");
+    (void) fprintf(sp, "DIMENSION-SIZES 5 3 4\n");
+    (void) fprintf(sp, "\n");
+    (void) HDfclose(sp);
 
  /*-------------------------------------------------------------------------
-  * TOOLTEST binin16.bin -c $srcdir/testfiles/binin16.conf -o binin16.h5
+  * TOOLTEST binin16.bin -c binin16.conf -o binin16.h5
   *-------------------------------------------------------------------------
   */
 
@@ -273,8 +304,22 @@ main(void)
     }
     (void) HDfclose(sp);
 
+    sp = HDfopen("binin16.conf", "w");
+    (void) fprintf(sp, "PATH /int/bin/16-bit\n");
+    (void) fprintf(sp, "INPUT-CLASS IN\n");
+    (void) fprintf(sp, "INPUT-SIZE    16\n");
+    (void) fprintf(sp, "INPUT-BYTE-ORDER %s\n", machine_order);
+    (void) fprintf(sp, "RANK 3\n");
+    (void) fprintf(sp, "OUTPUT-ARCHITECTURE STD\n");
+    (void) fprintf(sp, "OUTPUT-BYTE-ORDER LE\n");
+    (void) fprintf(sp, "DIMENSION-SIZES 2 3 4\n");
+    (void) fprintf(sp, "CHUNKED-DIMENSION-SIZES 2 2 2\n");
+    (void) fprintf(sp, "MAXIMUM-DIMENSIONS -1 -1 8\n");
+    (void) fprintf(sp, "\n");
+    (void) HDfclose(sp);
+
  /*-------------------------------------------------------------------------
-  * TOOLTEST binuin16.bin -c $srcdir/testfiles/binuin16.conf -o binuin16.h5
+  * TOOLTEST binuin16.bin -c binuin16.conf -o binuin16.h5
   *-------------------------------------------------------------------------
   */
     sp = HDfopen("binuin16.bin", OPEN_FLAGS);
@@ -290,10 +335,22 @@ main(void)
     }
     (void) HDfclose(sp);
 
-
+    sp = HDfopen("binuin16.conf", "w");
+    (void) fprintf(sp, "PATH /int/buin/16-bit\n");
+    (void) fprintf(sp, "INPUT-CLASS UIN\n");
+    (void) fprintf(sp, "INPUT-SIZE    16\n");
+    (void) fprintf(sp, "INPUT-BYTE-ORDER %s\n", machine_order);
+    (void) fprintf(sp, "RANK 3\n");
+    (void) fprintf(sp, "OUTPUT-ARCHITECTURE STD\n");
+    (void) fprintf(sp, "OUTPUT-BYTE-ORDER BE\n");
+    (void) fprintf(sp, "DIMENSION-SIZES 2 3 4\n");
+    (void) fprintf(sp, "CHUNKED-DIMENSION-SIZES 2 2 2\n");
+    (void) fprintf(sp, "MAXIMUM-DIMENSIONS -1 -1 8\n");
+    (void) fprintf(sp, "\n");
+    (void) HDfclose(sp);
 
  /*-------------------------------------------------------------------------
-  * TOOLTEST binin8.bin -c $srcdir/testfiles/binin8.conf  -o binin8.h5
+  * TOOLTEST binin8.bin -c binin8.conf  -o binin8.h5
   *-------------------------------------------------------------------------
   */
 
@@ -310,13 +367,27 @@ main(void)
     }
     (void) HDfclose(sp);
 
-#endif /* UNICOS */
-
-
+    sp = HDfopen("binin8.conf", "w");
+    (void) fprintf(sp, "PATH /int/bin/8-bit\n");
+    (void) fprintf(sp, "INPUT-CLASS IN\n");
+    (void) fprintf(sp, "INPUT-SIZE    8\n");
+    (void) fprintf(sp, "INPUT-BYTE-ORDER %s\n", machine_order);
+    (void) fprintf(sp, "RANK 3\n");
+    (void) fprintf(sp, "OUTPUT-CLASS IN\n");
+    (void) fprintf(sp, "OUTPUT-SIZE    16\n");
+    (void) fprintf(sp, "OUTPUT-ARCHITECTURE STD\n");
+    (void) fprintf(sp, "OUTPUT-BYTE-ORDER LE\n");
+    (void) fprintf(sp, "DIMENSION-SIZES 5 3 4\n");
+    (void) fprintf(sp, "CHUNKED-DIMENSION-SIZES 2 2 2\n");
+    (void) fprintf(sp, "MAXIMUM-DIMENSIONS -1 -1 -1\n");
+    (void) fprintf(sp, "COMPRESSION-PARAM 3\n");
+    (void) fprintf(sp, "\n");
+    (void) HDfclose(sp);
 
+#endif /* UNICOS */
 
  /*-------------------------------------------------------------------------
-  * TOOLTEST binfp64.bin -c $srcdir/testfiles/binfp64.conf -o binfp64.h5
+  * TOOLTEST binfp64.bin -c binfp64.conf -o binfp64.h5
   *-------------------------------------------------------------------------
   */
 
@@ -337,10 +408,23 @@ main(void)
     }
     (void) HDfclose(sp);
 
-
+    sp = HDfopen("binfp64.conf", "w");
+    (void) fprintf(sp, "PATH /fp/bin/64-bit\n");
+    (void) fprintf(sp, "INPUT-CLASS FP\n");
+    (void) fprintf(sp, "INPUT-SIZE    64\n");
+    (void) fprintf(sp, "INPUT-BYTE-ORDER %s\n", machine_order);
+    (void) fprintf(sp, "RANK 3\n");
+    (void) fprintf(sp, "OUTPUT-ARCHITECTURE IEEE\n");
+    (void) fprintf(sp, "OUTPUT-BYTE-ORDER LE\n");
+    (void) fprintf(sp, "DIMENSION-SIZES 5 3 4\n");
+    (void) fprintf(sp, "CHUNKED-DIMENSION-SIZES 2 2 2\n");
+    (void) fprintf(sp, "MAXIMUM-DIMENSIONS -1 6 7\n");
+    (void) fprintf(sp, "COMPRESSION-PARAM 8\n");
+    (void) fprintf(sp, "\n");
+    (void) HDfclose(sp);
 
  /*-------------------------------------------------------------------------
-  * TOOLTEST binin8w.bin -c $srcdir/testfiles/binin8w.conf -o binin8w.h5
+  * TOOLTEST binin8w.bin -c binin8w.conf -o binin8w.h5
   *-------------------------------------------------------------------------
   */
 
@@ -357,13 +441,20 @@ main(void)
         }
         HDfclose(sp);
 
+        sp = HDfopen("binin8w.conf", "w");
+        (void) fprintf(sp, "INPUT-CLASS IN\n");
+        (void) fprintf(sp, "INPUT-SIZE    8\n");
+        (void) fprintf(sp, "INPUT-BYTE-ORDER %s\n", machine_order);
+        (void) fprintf(sp, "RANK 1\n");
+        (void) fprintf(sp, "OUTPUT-CLASS IN\n");
+        (void) fprintf(sp, "OUTPUT-SIZE    8\n");
+        (void) fprintf(sp, "OUTPUT-ARCHITECTURE STD\n");
+        (void) fprintf(sp, "OUTPUT-BYTE-ORDER LE\n");
+        (void) fprintf(sp, "DIMENSION-SIZES 4\n");
+        (void) fprintf(sp, "\n");
+        (void) HDfclose(sp);
 
     }
-
-
-
-
-
     return (EXIT_SUCCESS);
 }
 
diff --git a/tools/test/h5import/testfiles/binfp64.conf b/tools/test/h5import/testfiles/binfp64.conf
deleted file mode 100644
index 6b4c361..0000000
--- a/tools/test/h5import/testfiles/binfp64.conf
+++ /dev/null
@@ -1,13 +0,0 @@
-PATH /fp/bin/64-bit
-INPUT-CLASS FP
-INPUT-SIZE	64
-RANK 3
-DIMENSION-SIZES 5 3 4
-OUTPUT-ARCHITECTURE IEEE
-OUTPUT-BYTE-ORDER LE
-CHUNKED-DIMENSION-SIZES 2 2 2
-COMPRESSION-PARAM 8
-MAXIMUM-DIMENSIONS -1 6 7
-
-
-
diff --git a/tools/test/h5import/testfiles/binin16.conf b/tools/test/h5import/testfiles/binin16.conf
deleted file mode 100644
index 06869cb..0000000
--- a/tools/test/h5import/testfiles/binin16.conf
+++ /dev/null
@@ -1,12 +0,0 @@
-PATH /int/bin/16-bit
-INPUT-CLASS IN
-INPUT-SIZE	16
-RANK 3
-DIMENSION-SIZES 2 3 4
-CHUNKED-DIMENSION-SIZES 2 2 2
-MAXIMUM-DIMENSIONS -1 -1 8
-OUTPUT-ARCHITECTURE STD
-OUTPUT-BYTE-ORDER LE
-
-
-
diff --git a/tools/test/h5import/testfiles/binin32.conf b/tools/test/h5import/testfiles/binin32.conf
deleted file mode 100644
index 11996ef..0000000
--- a/tools/test/h5import/testfiles/binin32.conf
+++ /dev/null
@@ -1,12 +0,0 @@
-PATH /int/bin/32-bit
-INPUT-CLASS IN
-INPUT-SIZE	32
-RANK 3
-DIMENSION-SIZES 5 3 4
-OUTPUT-ARCHITECTURE STD
-OUTPUT-BYTE-ORDER BE
-CHUNKED-DIMENSION-SIZES 1 2 1
-
-
-
-
diff --git a/tools/test/h5import/testfiles/binin32.h5 b/tools/test/h5import/testfiles/binin32.h5
index fd8faa9..2ec5b7c 100644
--- a/tools/test/h5import/testfiles/binin32.h5
+++ b/tools/test/h5import/testfiles/binin32.h5
diff --git a/tools/test/h5import/testfiles/binin8.conf b/tools/test/h5import/testfiles/binin8.conf
deleted file mode 100644
index 1edd80a..0000000
--- a/tools/test/h5import/testfiles/binin8.conf
+++ /dev/null
@@ -1,16 +0,0 @@
-PATH /int/bin/8-bit
-INPUT-CLASS IN
-INPUT-SIZE	8
-OUTPUT-CLASS IN
-OUTPUT-SIZE 16
-RANK 3
-OUTPUT-ARCHITECTURE STD
-OUTPUT-BYTE-ORDER LE
-DIMENSION-SIZES 5 3 4
-CHUNKED-DIMENSION-SIZES 2 2 2
-MAXIMUM-DIMENSIONS -1 -1 -1
-COMPRESSION-PARAM 3
-
-
-
-
diff --git a/tools/test/h5import/testfiles/binin8w.conf b/tools/test/h5import/testfiles/binin8w.conf
deleted file mode 100644
index fccb4ac..0000000
--- a/tools/test/h5import/testfiles/binin8w.conf
+++ /dev/null
@@ -1,9 +0,0 @@
-
-INPUT-CLASS IN
-INPUT-SIZE  8
-RANK 1
-DIMENSION-SIZES 4
-OUTPUT-BYTE-ORDER LE
-OUTPUT-CLASS IN
-OUTPUT-SIZE 8
-OUTPUT-ARCHITECTURE STD
diff --git a/tools/test/h5import/testfiles/binuin16.conf b/tools/test/h5import/testfiles/binuin16.conf
deleted file mode 100644
index a4603df..0000000
--- a/tools/test/h5import/testfiles/binuin16.conf
+++ /dev/null
@@ -1,12 +0,0 @@
-PATH /int/buin/16-bit
-INPUT-CLASS UIN
-INPUT-SIZE	16
-RANK 3
-DIMENSION-SIZES 2 3 4
-CHUNKED-DIMENSION-SIZES 2 2 2
-MAXIMUM-DIMENSIONS -1 -1 8
-OUTPUT-ARCHITECTURE STD
-OUTPUT-BYTE-ORDER BE
-
-
-
diff --git a/tools/test/h5import/testfiles/binuin32.conf b/tools/test/h5import/testfiles/binuin32.conf
deleted file mode 100644
index a649e97..0000000
--- a/tools/test/h5import/testfiles/binuin32.conf
+++ /dev/null
@@ -1,12 +0,0 @@
-PATH /int/buin/32-bit
-INPUT-CLASS UIN
-INPUT-SIZE	32
-RANK 3
-DIMENSION-SIZES 5 3 4
-OUTPUT-ARCHITECTURE STD
-OUTPUT-BYTE-ORDER LE
-
-
-
-
-
diff --git a/tools/test/h5import/testfiles/tintsattrs_u32.ddl b/tools/test/h5import/testfiles/tintsattrs_u32.ddl
new file mode 100644
index 0000000..cf8889c
--- /dev/null
+++ b/tools/test/h5import/testfiles/tintsattrs_u32.ddl
@@ -0,0 +1,28 @@
+HDF5 "d-tintsattrs_u32.h5" {
+GROUP "/" {
+   DATASET "DU32BITS" {
+      DATATYPE  H5T_STD_U32LE
+      DATASPACE  SIMPLE { ( 3, 2 ) / ( 3, 2 ) }
+      STORAGE_LAYOUT {
+         CONTIGUOUS
+         SIZE 24
+         OFFSET 2048
+      }
+      FILTERS {
+         NONE
+      }
+      FILLVALUE {
+         FILL_TIME H5D_FILL_TIME_IFSET
+         VALUE  H5D_FILL_VALUE_DEFAULT
+      }
+      ALLOCATION_TIME {
+         H5D_ALLOC_TIME_LATE
+      }
+      DATA {
+      (0,0): 4294967292, 4294967264,
+      (1,0): 4294967280, 4294967168,
+      (2,0): 4294967232, 4294966784
+      }
+   }
+}
+}