Add test files

.devcontainer/devcontainer.json

@@ -0,0 +1,13 @@
+{
+    "image": "ghcr.io/tiejunms/azure_rtos_docker",
+
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"ms-vscode.cpptools",
+		"ms-vscode.cmake-tools"
+	],
+
+	"remoteUser": "vscode",
+
+    "runArgs": [ "--cap-add=NET_ADMIN"]
+}

test/cmake/.gitignore

@@ -0,0 +1,4 @@
+threadx
+filex
+coverage_report
+.run.sh

test/cmake/CMakeLists.txt

@@ -0,0 +1,128 @@
+cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
+cmake_policy(SET CMP0054 NEW)
+cmake_policy(SET CMP0057 NEW)
+
+project(levelx_test LANGUAGES C)
+
+# Set build configurations
+set(BUILD_CONFIGURATIONS default_build_coverage 
+                         free_sector_verify_build 
+                         full_build 
+                         standalone_build
+                         standalone_free_sector_verify_build
+                         standalone_full_build
+                         new_driver_interface_build
+                         nor_obsolete_cache_build
+                         nor_mapping_cache_build
+                         nor_obsolete_mapping_cache_build)
+set(CMAKE_CONFIGURATION_TYPES
+    ${BUILD_CONFIGURATIONS}
+    CACHE STRING "list of supported configuration types" FORCE)
+set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
+                                             ${CMAKE_CONFIGURATION_TYPES})
+list(GET CMAKE_CONFIGURATION_TYPES 0 BUILD_TYPE)
+if((NOT CMAKE_BUILD_TYPE) OR (NOT ("${CMAKE_BUILD_TYPE}" IN_LIST
+                                   CMAKE_CONFIGURATION_TYPES)))
+  set(CMAKE_BUILD_TYPE
+      "${BUILD_TYPE}"
+      CACHE STRING "Build Type of the project" FORCE)
+endif()
+
+message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+message(STATUS "Using toolchain file: ${CMAKE_TOOLCHAIN_FILE}.")
+set(FX_FAULT_TOLERANT_DEFINITIONS
+    -DFX_ENABLE_FAULT_TOLERANT -DFX_UPDATE_FILE_SIZE_ON_ALLOCATE
+    -DFX_FAULT_TOLERANT_TRANSACTION_FAIL_FUNCTION)
+set(default_build_coverage "")
+set(free_sector_verify_build -DLX_FREE_SECTOR_DATA_VERIFY)
+set(full_build -DLX_FREE_SECTOR_DATA_VERIFY
+               -DLX_DIRECT_READ
+               -DLX_NAND_FLASH_DIRECT_MAPPING_CACHE
+               -DLX_NOR_DISABLE_EXTENDED_CACHE
+               -DLX_THREAD_SAFE_ENABLE)
+# For Standalone builds LX_STANADLONE_ENABLE is defined in line 61
+set(standalone_build -DLX_STANDALONE_ENABLE)
+set(standalone_free_sector_verify_build -DLX_STANDALONE_ENABLE ${free_sector_verify_build})
+set(standalone_full_build -DLX_STANDALONE_ENABLE ${full_build})
+set(new_driver_interface_build -DLX_NOR_ENABLE_CONTROL_BLOCK_FOR_DRIVER_INTERFACE
+                               -DLX_NAND_ENABLE_CONTROL_BLOCK_FOR_DRIVER_INTERFACE)
+set(nor_obsolete_cache_build   -DLX_NOR_ENABLE_OBSOLETE_COUNT_CACHE)
+set(nor_mapping_cache_build -DLX_NOR_ENABLE_MAPPING_BITMAP)
+set(nor_obsolete_mapping_cache_build -DLX_NOR_ENABLE_MAPPING_BITMAP
+                               -DLX_NOR_ENABLE_OBSOLETE_COUNT_CACHE)
+
+add_compile_options(
+  -m32
+  -std=c99
+  -ggdb
+  -g3
+  -gdwarf-2
+  -fdiagnostics-color
+  -Werror
+  ${${CMAKE_BUILD_TYPE}})
+add_link_options(-m32)
+
+enable_testing()
+
+if(CMAKE_BUILD_TYPE MATCHES "standalone.*")
+  set(LX_STANDALONE_ENABLE 
+      ON 
+      CACHE BOOL "LevelX standalone enabled(No Azure RTOS ThreadX)" FORCE)
+  set(FX_STANDALONE_ENABLE 
+      ON 
+      CACHE BOOL "FileX standalone enabled(No Azure RTOS ThreadX)" FORCE)
+endif()
+
+add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/../.. levelx)
+add_subdirectory(regression)
+add_subdirectory(samples)
+
+# Coverage
+if(CMAKE_BUILD_TYPE MATCHES ".*_coverage")
+  target_compile_options(levelx PRIVATE -fprofile-arcs -ftest-coverage)
+  target_link_options(levelx PRIVATE -fprofile-arcs -ftest-coverage)
+endif()
+
+
+# Build ThreadX library once
+execute_process(COMMAND ${CMAKE_CURRENT_LIST_DIR}/run.sh build_libs)
+add_custom_target(build_libs ALL COMMAND ${CMAKE_CURRENT_LIST_DIR}/run.sh
+                                             build_libs)
+add_dependencies(levelx build_libs)
+target_include_directories(levelx PUBLIC ${CMAKE_BINARY_DIR}/../libs/inc)
+if(NOT LX_STANDALONE_ENABLE)
+    add_library(threadx SHARED IMPORTED GLOBAL)
+    add_library("azrtos::threadx" ALIAS threadx)
+    set_target_properties(
+      threadx PROPERTIES IMPORTED_LOCATION
+                         ${CMAKE_BINARY_DIR}/../libs/threadx/libthreadx.so)
+    add_library(filex SHARED IMPORTED GLOBAL)
+    add_library("azrtos::filex" ALIAS filex)
+    set_target_properties(filex PROPERTIES IMPORTED_LOCATION
+                   ${CMAKE_BINARY_DIR}/../libs/filex/libfilex.so)
+else()
+    get_filename_component(
+    externals ${CMAKE_CURRENT_SOURCE_DIR} ABSOLUTE)
+    add_subdirectory(${externals}/filex filex)
+    add_library("azrtos::filex" ALIAS filex)
+endif()
+
+target_compile_options(
+  levelx
+  PRIVATE -Werror
+          -Wall
+          -Wextra
+          -pedantic
+          -fmessage-length=0
+          -fsigned-char
+          -ffunction-sections
+          -fdata-sections
+          -Wunused
+          -Wuninitialized
+          -Wmissing-declarations
+          -Wconversion
+          -Wpointer-arith
+          -Wshadow
+          -Wlogical-op
+          -Waggregate-return
+          -Wfloat-equal)

test/cmake/coverage.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+set -e
+
+cd $(dirname $0)
+mkdir -p coverage_report/$1
+gcovr --object-directory=build/$1/levelx/CMakeFiles/levelx.dir/common/src -r ../../common/src --xml-pretty --output coverage_report/$1.xml
+gcovr --object-directory=build/$1/levelx/CMakeFiles/levelx.dir/common/src -r ../../common/src --html --html-details --output coverage_report/$1/index.html

test/cmake/libs/CMakeLists.txt

@@ -0,0 +1,38 @@
+cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
+
+project(libs LANGUAGES C)
+
+if($ENV{ENABLE_64})
+  message(STATUS "Building for 64bit")
+else()
+  add_compile_options(-m32)
+  add_link_options(-m32)
+  message(STATUS "Building for 32bit")
+endif()
+message(STATUS "Using toolchain file: ${CMAKE_TOOLCHAIN_FILE}.")
+
+get_filename_component(
+  externals ${CMAKE_CURRENT_SOURCE_DIR}/.. ABSOLUTE)
+
+if(NOT LX_STANDALONE_ENABLE)
+    add_subdirectory(${externals}/threadx threadx)
+endif()
+add_subdirectory(${externals}/filex filex)
+target_compile_options(threadx PRIVATE -DTX_ENABLE_EVENT_TRACE)
+if(NOT DEFINED ENV{ENABLE_IDLE})
+  target_compile_options(threadx PRIVATE -DTX_LINUX_NO_IDLE_ENABLE)
+endif()
+
+
+if((NOT LX_STANDALONE_ENABLE) OR (NOT FX_STANDALONE_ENABLE))
+    foreach(lib threadx filex)
+      get_target_property(dirs ${lib} INCLUDE_DIRECTORIES)
+      execute_process(COMMAND mkdir -p ${CMAKE_BINARY_DIR}/inc)
+      foreach(dir ${dirs})
+        file(GLOB header_files ${dir}/*.h)
+        foreach(header_file ${header_files})
+          execute_process(COMMAND ln -sf ${header_file} ${CMAKE_BINARY_DIR}/inc)
+        endforeach()
+      endforeach()
+    endforeach()
+endif()

test/cmake/regression/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.0.0 FATAL_ERROR)
+cmake_policy(SET CMP0057 NEW)
+
+project(regression_test LANGUAGES C)
+
+set(SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/../../regression)
+
+set(regression_test_cases
+    ${SOURCE_DIR}/levelx_nand_flash_test.c
+    ${SOURCE_DIR}/levelx_nor_flash_test.c
+    ${SOURCE_DIR}/levelx_nor_flash_test_cache.c)
+
+foreach(test_case ${regression_test_cases} ${regression_test_cases_exfat})
+  get_filename_component(test_name ${test_case} NAME_WE)
+  add_executable(${test_name} ${test_case})
+  target_link_libraries(${test_name} PRIVATE azrtos::filex)
+  target_link_libraries(${test_name} PRIVATE azrtos::levelx)
+  target_compile_definitions(${test_name} PRIVATE BATCH_TEST)
+  add_test(${CMAKE_BUILD_TYPE}::${test_name} ${test_name})
+endforeach()

test/cmake/run.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+cd $(dirname $0)
+
+# if threadx repo does not exist, clone it
+[ -d threadx ] || git clone https://github.com/azure-rtos/threadx.git --depth 1
+[ -d filex ] || git clone https://github.com/azure-rtos/filex.git --depth 1
+[ -f .run.sh ] || ln -sf threadx/scripts/cmake_bootstrap.sh .run.sh
+./.run.sh $*

test/cmake/samples/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.0.0 FATAL_ERROR)
+cmake_policy(SET CMP0057 NEW)
+
+project(samples LANGUAGES C)
+
+set(SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/../../../samples)
+
+set(sample_files
+    ${SOURCE_DIR}/demo_filex_nand_flash.c
+    ${SOURCE_DIR}/demo_filex_nor_flash.c)
+
+foreach(sample_file ${sample_files})
+  get_filename_component(sample_file_name ${sample_file} NAME_WE)
+  add_executable(${sample_file_name} ${sample_file})
+  target_link_libraries(${sample_file_name} PRIVATE azrtos::filex)
+  target_link_libraries(${sample_file_name} PRIVATE azrtos::levelx)
+endforeach()

test/regression/levelx_nand_flash_test.c

@@ -0,0 +1,2384 @@
+/* Basic NOR flash tests...  */
+
+#include <stdio.h>
+#include "lx_api.h"
+
+#define     DEMO_STACK_SIZE         4096
+
+
+/* Define the ThreadX object control blocks...  */
+#ifndef LX_STANDALONE_ENABLE
+TX_THREAD               thread_0;
+#endif
+UCHAR                   thread_0_stack[DEMO_STACK_SIZE];
+
+//#define EXTENDED_CACHE
+#ifdef EXTENDED_CACHE
+UCHAR                   cache_memory[50000];
+#endif
+
+/* Define LevelX structures.  */
+
+LX_NAND_FLASH   nand_sim_flash;
+ULONG           buffer[2048];
+ULONG           readbuffer[2048];
+
+extern ULONG    *nand_flash_memory;
+
+/* Define LevelX NOR flash simulator prototoypes.  */
+
+UINT  _lx_nand_flash_simulator_erase_all(VOID);
+UINT  _lx_nand_flash_simulator_initialize(LX_NAND_FLASH *nand_flash);
+
+VOID  _fx_nand_flash_read_sectors(ULONG logical_sector, ULONG sectors, UCHAR *destination_buffer);
+VOID  _fx_nand_flash_write_sectors(ULONG logical_sector, ULONG sectors, UCHAR *source_buffer);
+
+#if 0
+typedef struct SECTOR_STRUCT
+{
+    ULONG       words[2048/4];
+} SECTOR;
+
+SECTOR  test_write[8];
+SECTOR  test_read[8];
+#endif
+
+#if 1
+
+UCHAR   byte_buffer[2048];
+UCHAR   ecc_bytes[24];
+UCHAR   lx_ecc_buffer[24];
+
+#endif
+
+/* Define thread prototypes.  */
+
+void    thread_0_entry(ULONG thread_input);
+
+VOID ComputePageECC(UCHAR *data, INT size, UCHAR *code);
+INT  CorrectPageECC(UCHAR *data, INT size, UCHAR *code);
+
+
+
+/* Define main entry point.  */
+
+int main()
+{
+  
+    /* Enter the ThreadX kernel.  */
+#ifndef LX_STANDALONE_ENABLE
+    tx_kernel_enter();
+#else
+    thread_0_entry(0);
+#endif
+
+}
+
+
+/* Define what the initial system looks like.  */
+#ifndef LX_STANDALONE_ENABLE
+void    tx_application_define(void *first_unused_memory)
+{
+
+
+    /* Create the main thread.  */
+    tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0,  
+            thread_0_stack, DEMO_STACK_SIZE, 
+            1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);
+}
+#endif
+
+
+#define NAND_MEMORY_SIZE 2056
+ULONG nand_memory_space[NAND_MEMORY_SIZE];
+
+/* For random read/write test */
+#define MAX_SECTOR_ADDRESS 64000*4
+#define SECTOR_SIZE 512
+
+UCHAR local_data_buffer[MAX_SECTOR_ADDRESS * SECTOR_SIZE];
+
+/* Define the test threads.  */
+
+void    thread_0_entry(ULONG thread_input)
+{
+
+ULONG   i, j, sector;
+UINT    status;
+
+ULONG   *word_ptr;
+UCHAR   *byte_ptr;
+
+  
+    /* Erase the simulated NOR flash.  */
+    _lx_nand_flash_simulator_erase_all();
+    
+    /* Initialize LevelX.  */
+    _lx_nand_flash_initialize();
+
+    /* Test 1: Simple write 520 sectors and read 520 sectors.  */
+    printf("Test 1: Simple write-read 520 sectors...........");
+
+    status = lx_nand_flash_format(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+    if (status != LX_SUCCESS)
+    {
+        printf("FAILED!\n");
+#ifdef BATCH_TEST
+        exit(1);
+#endif
+        while (1)
+        {
+        }
+    }
+
+    status= lx_nand_flash_open(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+    if (status != LX_SUCCESS)
+    {
+        printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+    while(1)
+        {
+        }
+    }
+#ifdef EXTENDED_CACHE
+    lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
+#endif
+    
+    /* Write 520 sectors....  */
+    for (i = 0; i < 520; i++)
+    {
+        for (j = 0; j < 512; j++)
+          buffer[j] =  i;
+        
+        status =  lx_nand_flash_sector_write(&nand_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+    
+    /* Close and reopen the flash. */
+    lx_nand_flash_close(&nand_sim_flash);
+
+    LX_MEMSET(nand_memory_space, 0, sizeof(nand_memory_space));
+    LX_MEMSET(&nand_sim_flash, 0, sizeof(nand_sim_flash));
+
+    status = lx_nand_flash_open(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+    if (status != LX_SUCCESS)
+    {
+        printf("FAILED!\n");
+#ifdef BATCH_TEST
+        exit(1);
+#endif
+        while (1)
+        {
+        }
+    }
+
+    /* Read back 520 sectors...  */
+    for (i = 0; i < 520; i++)
+    {
+        
+        status =  lx_nand_flash_sector_read(&nand_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          printf("FAILED!\n");
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if (buffer[j] !=  i)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+    }
+
+    _lx_nand_flash_close(&nand_sim_flash);
+    printf("SUCCESS!\n");
+
+    /* Test 2: Write same sector 320 times.  */
+    printf("Test 2: Write same sector 320 times.............");
+    
+    /* Reinitialize...  */    
+    _lx_nand_flash_simulator_erase_all();
+    
+    
+    lx_nand_flash_initialize();
+
+    status = lx_nand_flash_format(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+
+
+    lx_nand_flash_open(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+#ifdef EXTENDED_CACHE
+    lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
+#endif
+    
+    for (j = 0; j < 512; j++)
+         buffer[j] =  0xFFFFFFFF;
+    
+    /* Write same sector 320 sectors....  */
+    for (i = 0; i < 320; i++)
+    {
+        for (j = 0; j < 512; j++)
+          buffer[j] =  i;
+      
+        if (i == 319)
+            buffer[j-1]--;
+        status =  lx_nand_flash_sector_write(&nand_sim_flash, 7, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        status =  lx_nand_flash_sector_read(&nand_sim_flash, 7, readbuffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if (buffer[j] !=  readbuffer[j])
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+        
+        /* Write other sectors just to have additional sectors to manage.  */
+        if (i == 1)
+          lx_nand_flash_sector_write(&nand_sim_flash, 1, buffer);
+        if (i == 16)
+          lx_nand_flash_sector_write(&nand_sim_flash, 16, buffer);
+        if (i == 32)
+          lx_nand_flash_sector_write(&nand_sim_flash, 32, buffer);
+        if (i == 48)
+          lx_nand_flash_sector_write(&nand_sim_flash, 48, buffer);
+        if (i == 64)
+          lx_nand_flash_sector_write(&nand_sim_flash, 64, buffer);
+        if (i == 80)
+          lx_nand_flash_sector_write(&nand_sim_flash, 80, buffer);
+        if (i == 96)
+          lx_nand_flash_sector_write(&nand_sim_flash, 96, buffer);
+        if (i == 112)
+          lx_nand_flash_sector_write(&nand_sim_flash, 112, buffer);
+    }
+
+    status =  lx_nand_flash_defragment(&nand_sim_flash);
+
+    
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 319)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nand_flash_sector_read(&nand_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+
+    status =  lx_nand_flash_defragment(&nand_sim_flash);
+    
+    if (status != LX_NOT_SUPPORTED)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+   
+    status =  lx_nand_flash_close(&nand_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    printf("SUCCESS!\n");
+  
+    printf("Test 3: Page copy test..........................");
+
+    /* Reinitialize...  */
+    _lx_nand_flash_simulator_erase_all();
+
+
+    lx_nand_flash_initialize();
+
+    status = lx_nand_flash_format(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+
+
+    lx_nand_flash_open(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+
+    for (j = 0; j < 512; j++)
+        buffer[j] = 0xFFFFFFFF;
+
+    status = lx_nand_flash_sector_write(&nand_sim_flash, 0, buffer);
+
+    /* Write same sector 320 sectors....  */
+    for (i = 256; i < 512; i++)
+    {
+        for (j = 0; j < 512; j++)
+            buffer[j] = i;
+
+        if (i == 300) continue;
+
+        status = lx_nand_flash_sector_write(&nand_sim_flash, i, buffer);
+
+        if (status != LX_SUCCESS)
+        {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+            exit(1);
+#endif
+            while (1)
+            {
+            }
+        }
+    }
+
+    status = lx_nand_flash_sector_write(&nand_sim_flash, 300, buffer);
+    if (status != LX_SUCCESS)
+    {
+        printf("FAILED!\n");
+#ifdef BATCH_TEST
+        exit(1);
+#endif
+        while (1)
+        {
+        }
+    }
+
+    status = lx_nand_flash_sector_write(&nand_sim_flash, 400, buffer);
+    if (status != LX_SUCCESS)
+    {
+        printf("FAILED!\n");
+#ifdef BATCH_TEST
+        exit(1);
+#endif
+        while (1)
+        {
+        }
+    }
+
+    if (status != LX_SUCCESS)
+    {
+        printf("FAILED!\n");
+#ifdef BATCH_TEST
+        exit(1);
+#endif
+        while (1)
+        {
+        }
+    }
+    if (nand_sim_flash.lx_nand_flash_block_status_table[nand_sim_flash.lx_nand_flash_block_mapping_table[1]] & LX_NAND_BLOCK_STATUS_NON_SEQUENTIAL)
+    {
+        printf("FAILED!\n");
+#ifdef BATCH_TEST
+        exit(1);
+#endif
+        while (1)
+        {
+        }
+    }
+    
+    status =  lx_nand_flash_close(&nand_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    printf("SUCCESS!\n");
+
+    printf("Test 4: Random read/write test..................");
+
+    LX_MEMSET(local_data_buffer, 0xff, sizeof(local_data_buffer));
+
+    /* Reinitialize...  */
+    _lx_nand_flash_simulator_erase_all();
+
+
+    lx_nand_flash_initialize();
+
+    status = lx_nand_flash_format(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+    if (status != LX_SUCCESS)
+    {
+        printf("FAILED!\n");
+#ifdef BATCH_TEST
+        exit(1);
+#endif
+        while (1)
+        {
+        }
+    }
+
+    status = lx_nand_flash_open(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+    if (status != LX_SUCCESS)
+    {
+        printf("FAILED!\n");
+#ifdef BATCH_TEST
+        exit(1);
+#endif
+        while (1)
+        {
+        }
+    }
+
+    static ULONG loop_count = 200;
+    ULONG operation;
+    ULONG sector_number;
+    ULONG data_byte;
+    ULONG sector_count;
+    static ULONG read_count = 0;
+    static ULONG write_count = 0;
+    static ULONG release_count = 0;
+    static ULONG reopen_count = 0;
+
+    while (loop_count--)
+    {
+        operation = (ULONG)rand() % 32768;
+        if (operation < 16384)
+        {
+            sector_number = ((ULONG)rand() * (ULONG)rand()) % MAX_SECTOR_ADDRESS;
+            sector_count = ((ULONG)rand() % 768) + 1;
+            if (sector_number + sector_count > MAX_SECTOR_ADDRESS)
+            {
+                sector_count = MAX_SECTOR_ADDRESS - sector_number;
+            }
+
+            while (sector_count--)
+            {
+                status = lx_nand_flash_sector_read(&nand_sim_flash, sector_number, readbuffer);
+                if (status != LX_SUCCESS)
+                {
+                    printf("FAILED!\n");
+#ifdef BATCH_TEST
+                    exit(1);
+#endif
+                    while (1)
+                    {
+                    }
+                }
+#ifdef FULL_SECTOR_DATA_VERIFY
+                status = memcmp((local_data_buffer + sector_number * SECTOR_SIZE), readbuffer, SECTOR_SIZE);
+#else
+                status = *(ULONG*)(local_data_buffer + sector_number * SECTOR_SIZE) - readbuffer[0];
+#endif
+                if (status != 0)
+                {
+                    printf("FAILED!\n");
+#ifdef BATCH_TEST
+                    exit(1);
+#endif
+                    while (1)
+                    {
+                    }
+                }
+                read_count++;
+                sector_number++;
+            }
+        }
+        else if (operation < 29491)
+        {
+            sector_number = ((ULONG)rand() * (ULONG)rand()) % MAX_SECTOR_ADDRESS;
+            sector_count = ((ULONG)rand() % 768) + 1;
+            if (sector_number + sector_count > MAX_SECTOR_ADDRESS)
+            {
+                sector_count = MAX_SECTOR_ADDRESS - sector_number;
+            }
+
+            while (sector_count--)
+            {
+                data_byte = (ULONG)rand();
+
+#ifdef FULL_SECTOR_DATA_VERIFY
+                LX_MEMSET((local_data_buffer + sector_number * SECTOR_SIZE), data_byte, SECTOR_SIZE);
+#else
+                *(ULONG*)(local_data_buffer + sector_number * SECTOR_SIZE) = data_byte;
+#endif
+                status = lx_nand_flash_sector_write(&nand_sim_flash, sector_number, local_data_buffer + sector_number * SECTOR_SIZE);
+                if (status != LX_SUCCESS)
+                {
+                    printf("FAILED!\n");
+#ifdef BATCH_TEST
+                    exit(1);
+#endif
+                    while (1)
+                    {
+                    }
+                }
+                write_count++;
+                sector_number++;
+            }
+        }
+        else if(operation < 32760)
+        {
+            sector_number = ((ULONG)rand() * (ULONG)rand()) % MAX_SECTOR_ADDRESS;
+            data_byte = 0xffffffff;
+            sector_count = ((ULONG)rand() % 768) + 1;
+            if (sector_number + sector_count > MAX_SECTOR_ADDRESS)
+            {
+                sector_count = MAX_SECTOR_ADDRESS - sector_number;
+            }
+
+            while (sector_count--)
+            {
+                
+#ifdef FULL_SECTOR_DATA_VERIFY
+                LX_MEMSET((local_data_buffer + sector_number * SECTOR_SIZE), data_byte, SECTOR_SIZE);
+#else
+                * (ULONG*)(local_data_buffer + sector_number * SECTOR_SIZE) = data_byte;
+#endif
+                status = lx_nand_flash_sector_release(&nand_sim_flash, sector_number);
+                if (status != LX_SUCCESS)
+                {
+                    printf("FAILED!\n");
+#ifdef BATCH_TEST
+                    exit(1);
+#endif
+                    while (1)
+                    {
+                    }
+                }
+                release_count++;
+                sector_number++;
+            }
+        }
+        else
+        {
+            /* Close and reopen the flash. */
+            status = lx_nand_flash_close(&nand_sim_flash);
+            if (status != LX_SUCCESS)
+            {
+                printf("FAILED!\n");
+#ifdef BATCH_TEST
+                exit(1);
+#endif
+                while (1)
+                {
+                }
+            }
+
+            status = lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+            if (status != LX_SUCCESS)
+            {
+                printf("FAILED!\n");
+#ifdef BATCH_TEST
+                exit(1);
+#endif
+                while (1)
+                {
+                }
+            }
+            reopen_count++;
+        }
+    }
+
+    printf("SUCCESS!\n");
+
+#if 0
+    /* Point at the simulated NOR flash memory.  */
+    word_ptr =  nand_flash_memory;
+    
+   
+    /* Test 3: Corrupt block 0, simulate a power interruption during erase of block 0, 
+       after the erase, but before the erase count is setup.  */
+    printf("Test 3: Block erase-initialize interrupted......");
+    word_ptr[0] =  0xFFFFFFFF;
+    word_ptr[3] =  0x00000000;  /* This simulates a non-erased block.  */
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+#ifdef EXTENDED_CACHE
+    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
+#endif
+    
+    if ((status != LX_SUCCESS) ||
+        (nand_sim_flash.lx_nand_flash_free_pages != 111) ||
+        (nand_sim_flash.lx_nand_flash_mapped_pages != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    status =  lx_nand_flash_close(&nand_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+   
+    /* Corrupt block 0, simulate a power interruption after erase of block 0, 
+       but before erase count is setup.  */
+    word_ptr[0] =  0xFFFFFFFF;
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+#ifdef EXTENDED_CACHE
+    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
+#endif
+    
+    if ((status != LX_SUCCESS) ||
+        (nand_sim_flash.lx_nand_flash_free_pages != 111) ||
+        (nand_sim_flash.lx_nand_flash_mapped_pages != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nand_flash_close(&nand_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    printf("SUCCESS!\n");
+
+
+    /* Test 4: simulate a power interruption while a new page is being setup.  */
+    printf("Test 4: Power interrupted new page setup........");
+    
+    /* Partially setup new page.  */
+    byte_ptr =  (UCHAR *) word_ptr;
+    byte_ptr[2053] = 0xBF;      /* Set block 0/page 0 extra bytes to indicate block not empty.  */
+    word_ptr[528] =  0x60;
+
+    /* Open the flash and see if we recover properly.  We should mark this page as obsolete. */    
+    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+#ifdef EXTENDED_CACHE
+    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
+#endif
+    
+    if ((status != LX_SUCCESS) ||
+        (nand_sim_flash.lx_nand_flash_free_pages != 110) ||
+        (nand_sim_flash.lx_nand_flash_mapped_pages != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    status =  lx_nand_flash_close(&nand_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+
+    /* Simulate a power interruption after a new sector is allocated, after data
+       had been copied, and the superceeded bit is clear, but before the new entry can be
+       setup.  */
+       
+    /* Copy data block and reset spare.  */
+    byte_ptr[2053] = 0xBF;          /* Set block 0/page 0 extra bytes to indicate block not empty.  */
+    for (i = 1; i < 512; i++)       /* Fill block 0, page 1 data  */
+        word_ptr[i+528] = 0x60; 
+    word_ptr[i+528] =  0xFFFFFFFF;  /* Reset extra bytes for block 0, page 1 */
+    word_ptr[i+529] =  0xFFFFFFFF;  /* Reset extra bytes for block 0, page 1 */ 
+    
+    /* Set the superceded bit in block 1/page 1.   */
+    byte_ptr[37957] = 0x80;
+    
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+#ifdef EXTENDED_CACHE
+    lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
+#endif
+    
+    if ((status != LX_SUCCESS) ||
+        (nand_sim_flash.lx_nand_flash_free_pages != 110) ||
+        (nand_sim_flash.lx_nand_flash_mapped_pages != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    lx_nand_flash_close(&nand_sim_flash);
+
+    /* Simulate a power interruption after a new sector is allocated, after data
+       had been copied, and the superceeded bit is clear, the new entry is setup, but the old entry
+       has not been invalidated.  */
+    byte_ptr[2053] = 0xBF;          /* Set block 0/page 0 extra bytes to indicate block not empty.  */
+    for (i = 1; i < 512; i++)       /* Fill block 0, page 1 data  */
+        word_ptr[i+528] = 0x60;     
+    word_ptr[i+528] =  0xFFFFFFFF;  /* Reset extra bytes for block 0, page 1 */
+    word_ptr[i+529] =  0xFFFFFFFF;  /* Reset extra bytes for block 0, page 1 */
+    
+    byte_ptr =  (UCHAR *) word_ptr;
+
+    /* set the spare info in the new page.  */
+    byte_ptr[4162] = 0x60;          /* Setup extra bytes for block 0, page 1  */
+    byte_ptr[4163] = 0;             /* Setup extra bytes for block 0, page 1  */
+    byte_ptr[4164] = 0;             /* Setup extra bytes for block 0, page 1  */
+    byte_ptr[4165] = 0xC0;          /* Setup extra bytes for block 0, page 1  */
+
+    /* Set the superceded bit in block 1/page 1.   */
+    byte_ptr[37957] = 0x80;
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+#ifdef EXTENDED_CACHE
+    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
+#endif
+    
+    if ((status != LX_SUCCESS) ||
+        (nand_sim_flash.lx_nand_flash_free_pages != 110) ||
+        (nand_sim_flash.lx_nand_flash_mapped_pages != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nand_flash_sector_read(&nand_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+
+    status =  lx_nand_flash_defragment(&nand_sim_flash);
+    
+    if (status != LX_NOT_SUPPORTED)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+   
+    status =  lx_nand_flash_defragment(&nand_sim_flash);
+    
+    if (status != LX_NOT_SUPPORTED)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nand_flash_sector_read(&nand_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+
+    /* Read in reverse order to see if caching helps!  */
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nand_flash_sector_read(&nand_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_read(&nand_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+    status =  lx_nand_flash_sector_release(&nand_sim_flash, 7);
+    if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nand_flash_sector_release(&nand_sim_flash, 8);
+    if (status != LX_SECTOR_NOT_FOUND)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+    status =  lx_nand_flash_defragment(&nand_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nand_flash_close(&nand_sim_flash);
+
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+   
+    printf("SUCCESS!\n");
+#endif
+#if 0
+    printf("Test 5: Random write/read sector................");
+
+    /* Erase the simulated NOR flash.  */
+    _lx_nand_flash_simulator_erase_all();
+
+    /* Open the flash.  */    
+    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
+#ifdef EXTENDED_CACHE
+    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
+#endif
+    
+    if (status != LX_SUCCESS) 
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    /* Write 100 sectors....  */
+    for (i = 0; i < 100; i++)
+    {
+        for (j = 0; j < 512; j++)
+          buffer[j] =  i;
+        
+        status =  lx_nand_flash_sector_write(&nand_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+    
+    /* Read back 100 sectors...  */
+    for (i = 0; i < 100; i++)
+    {
+        
+        status =  lx_nand_flash_sector_read(&nand_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 512; j++)
+        {
+          
+          if (buffer[j] !=  i)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+    }
+    
+    /* Now, perform 1000 sector writes to randomly selected sectors, each time
+       reading first to make sure the previous contents are valid.  */
+    for (i = 0; i < 1000; i++)
+    {
+    
+        /* Pickup random sector.  */
+        sector =  (rand() % 100);
+
+        /* Read that sector.  */
+        status =  lx_nand_flash_sector_read(&nand_sim_flash, sector, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 512; j++)
+        {
+          
+          if ((buffer[j] & 0x0000FFFF) !=  sector)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+
+        /* Include the itteraction in the buffer to generate a new write.  */
+        for (j = 0; j < 512; j++)
+        {
+ 
+            buffer[j] =  (buffer[j] & 0x0000FFFF) | (i << 16);
+        }
+        
+        status =  lx_nand_flash_sector_write(&nand_sim_flash, sector, buffer);
+
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+    
+    status =  lx_nand_flash_close(&nand_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    printf("SUCCESS!\n");
+#endif
+    
+#if 0
+    
+  for (i = 0; i < 256; i++)
+  {
+  
+      /* Setup buffer.  */
+      for (j = 0; j < 2048; j++)
+          byte_buffer[j] =  (UCHAR) (rand() % 256);
+      
+      /* Call the ECC calculate routine.  */
+      ComputePageECC(byte_buffer, 2048, ecc_bytes);
+      status =  (UINT) CorrectPageECC(byte_buffer, 2048, ecc_bytes);
+      if (status != 0)
+      {
+        
+          /* Check for corrected return value.  */
+          if (status != 1)
+          {
+            while(1)
+            {
+            }
+          }
+      }
+      
+      /* Call LevelX ECC routines to do the same thing.  */
+      status =  lx_nand_flash_page_ecc_compute(&nand_sim_flash, byte_buffer, lx_ecc_buffer);
+
+      if (status != LX_SUCCESS)
+      {
+          printf("FAILED!\n");
+          while(1)
+          {
+          }
+      }
+
+//      ComputePageECC(byte_buffer, 2048, ecc_bytes);
+
+      
+      /* Determine if there is any difference between the original and the new ECC routine.  */
+      if ((ecc_bytes[0] != lx_ecc_buffer[0]) || 
+          (ecc_bytes[1] != lx_ecc_buffer[1]) ||
+          (ecc_bytes[2] != lx_ecc_buffer[2]) ||
+          (ecc_bytes[3] != lx_ecc_buffer[3]) ||
+          (ecc_bytes[4] != lx_ecc_buffer[4]) ||
+          (ecc_bytes[5] != lx_ecc_buffer[5]) ||
+          (ecc_bytes[6] != lx_ecc_buffer[6]) ||
+          (ecc_bytes[7] != lx_ecc_buffer[7]) ||  
+          (ecc_bytes[8] != lx_ecc_buffer[8]) ||  
+          (ecc_bytes[9] != lx_ecc_buffer[9]) ||
+          (ecc_bytes[10] != lx_ecc_buffer[10]) ||
+          (ecc_bytes[11] != lx_ecc_buffer[11]))
+      {
+         while(1)
+         {
+         }
+      }
+
+      status =  lx_nand_flash_page_ecc_check(&nand_sim_flash, byte_buffer, lx_ecc_buffer);
+
+      if (status != LX_SUCCESS)
+      {
+        
+          /* Is it the corrected status?  */
+          if (status !=  LX_NAND_ERROR_CORRECTED)
+          {
+            printf("FAILED!\n");
+            while(1)
+            {
+            }
+          }
+      }
+  }
+#endif
+
+#if 0  
+  for (i = 0; i < 256; i++)
+  {
+  
+      /* Setup buffer.  */
+      for (j = 0; j < 2048; j++)
+          byte_buffer[j] =  (UCHAR) (rand() % 256);
+      
+      /* Call the ECC calculate routine.  */
+      ComputePageECC(byte_buffer, 2048, ecc_bytes);
+      
+      /* Corrupt a bit in each 256 byte page.  */
+      if (byte_buffer[7] & 1)
+          byte_buffer[7] =  byte_buffer[7] & 0xFE;
+      else
+          byte_buffer[7] =  byte_buffer[7] | 1;
+ 
+      if (byte_buffer[277] & 1)
+          byte_buffer[277] =  byte_buffer[277] & 0xFE;
+      else
+          byte_buffer[277] =  byte_buffer[277] | 1;
+
+      if (byte_buffer[577] & 1)
+          byte_buffer[577] =  byte_buffer[577] & 0xFE;
+      else
+          byte_buffer[577] =  byte_buffer[577] | 1;
+      
+      if (byte_buffer[777] & 1)
+          byte_buffer[777] =  byte_buffer[777] & 0xFE;
+      else
+          byte_buffer[777] =  byte_buffer[777] | 1;
+      
+      if (byte_buffer[1077] & 1)
+          byte_buffer[1077] =  byte_buffer[1077] & 0xFE;
+      else
+          byte_buffer[1077] =  byte_buffer[1077] | 1;
+
+      if (byte_buffer[1297] & 1)
+          byte_buffer[1297] =  byte_buffer[1297] & 0xFE;
+      else
+          byte_buffer[1297] =  byte_buffer[1297] | 1;
+      
+      if (byte_buffer[1636] & 1)
+          byte_buffer[1636] =  byte_buffer[1636] & 0xFE;
+      else
+          byte_buffer[1636] =  byte_buffer[1636] | 1;
+
+      if (byte_buffer[1892] & 1)
+          byte_buffer[1892] =  byte_buffer[1892] & 0xFE;
+      else
+          byte_buffer[1892] =  byte_buffer[1892] | 1;
+     
+      
+      status =  (UINT) CorrectPageECC(byte_buffer, 2048, ecc_bytes);
+      if (status != 0)
+      {
+        
+          /* Check for corrected return value.  */
+          if (status != 1)
+          {
+            while(1)
+            {
+            }
+          }
+      }
+      
+      /* Call LevelX ECC routines to do the same thing.  */
+      status =  lx_nand_flash_page_ecc_compute(&nand_sim_flash, byte_buffer, lx_ecc_buffer);
+
+      if (status != LX_SUCCESS)
+      {
+          printf("FAILED!\n");
+          while(1)
+          {
+          }
+      }
+
+
+      
+      /* Determine if there is any difference between the original and the new ECC routine.  */
+      if ((ecc_bytes[0] != lx_ecc_buffer[0]) || 
+          (ecc_bytes[1] != lx_ecc_buffer[1]) ||
+          (ecc_bytes[2] != lx_ecc_buffer[2]) ||
+          (ecc_bytes[3] != lx_ecc_buffer[3]) ||
+          (ecc_bytes[4] != lx_ecc_buffer[4]) ||
+          (ecc_bytes[5] != lx_ecc_buffer[5]) ||
+          (ecc_bytes[6] != lx_ecc_buffer[6]) ||
+          (ecc_bytes[7] != lx_ecc_buffer[7]) ||  
+          (ecc_bytes[8] != lx_ecc_buffer[8]) ||  
+          (ecc_bytes[9] != lx_ecc_buffer[9]) ||
+          (ecc_bytes[10] != lx_ecc_buffer[10]) ||
+          (ecc_bytes[11] != lx_ecc_buffer[11]))
+      {
+         while(1)
+         {
+         }
+      }
+
+      /* Corrupt a bit in each 256 byte page.  */
+      if (byte_buffer[7] & 1)
+          byte_buffer[7] =  byte_buffer[7] & 0xFE;
+      else
+          byte_buffer[7] =  byte_buffer[7] | 1;
+ 
+      if (byte_buffer[277] & 1)
+          byte_buffer[277] =  byte_buffer[277] & 0xFE;
+      else
+          byte_buffer[277] =  byte_buffer[277] | 1;
+
+      if (byte_buffer[577] & 1)
+          byte_buffer[577] =  byte_buffer[577] & 0xFE;
+      else
+          byte_buffer[577] =  byte_buffer[577] | 1;
+      
+      if (byte_buffer[777] & 1)
+          byte_buffer[777] =  byte_buffer[777] & 0xFE;
+      else
+          byte_buffer[777] =  byte_buffer[777] | 1;
+      
+      if (byte_buffer[1077] & 1)
+          byte_buffer[1077] =  byte_buffer[1077] & 0xFE;
+      else
+          byte_buffer[1077] =  byte_buffer[1077] | 1;
+
+      if (byte_buffer[1297] & 1)
+          byte_buffer[1297] =  byte_buffer[1297] & 0xFE;
+      else
+          byte_buffer[1297] =  byte_buffer[1297] | 1;
+      
+      if (byte_buffer[1636] & 1)
+          byte_buffer[1636] =  byte_buffer[1636] & 0xFE;
+      else
+          byte_buffer[1636] =  byte_buffer[1636] | 1;
+
+      if (byte_buffer[1892] & 1)
+          byte_buffer[1892] =  byte_buffer[1892] & 0xFE;
+      else
+          byte_buffer[1892] =  byte_buffer[1892] | 1;
+      
+      status =  lx_nand_flash_page_ecc_check(&nand_sim_flash, byte_buffer, lx_ecc_buffer);
+
+      if (status != LX_SUCCESS)
+      {
+        
+          /* Is it the corrected status?  */
+          if (status !=  LX_NAND_ERROR_CORRECTED)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+      }
+
+      /* Call LevelX ECC routines to create the ECC over the corrected buffer.  */
+      status =  lx_nand_flash_page_ecc_compute(&nand_sim_flash, byte_buffer, lx_ecc_buffer);
+
+      if (status != LX_SUCCESS)
+      {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+      }
+
+  }
+
+
+
+#endif
+    
+#if 0  
+
+  /* Corrupting ECC code is detected and returns a failure... this test is not valid!  */
+
+  for (i = 0; i < 256; i++)
+  {
+  
+      /* Setup buffer.  */
+      for (j = 0; j < 2048; j++)
+          byte_buffer[j] =  (UCHAR) (rand() % 256);
+      
+      /* Call the ECC calculate routine.  */
+      ComputePageECC(byte_buffer, 2048, ecc_bytes);
+      
+      
+      /* Call LevelX ECC routines to do the same thing.  */
+      status =  lx_nand_flash_page_ecc_compute(&nand_sim_flash, byte_buffer, lx_ecc_buffer);
+
+      if (status != LX_SUCCESS)
+      {
+          printf("FAILED!\n");
+          while(1)
+          {
+          }
+      }
+
+      /* Determine if there is any difference between the original and the new ECC routine.  */
+      if ((ecc_bytes[0] != lx_ecc_buffer[0]) || 
+          (ecc_bytes[1] != lx_ecc_buffer[1]) ||
+          (ecc_bytes[2] != lx_ecc_buffer[2]) ||
+          (ecc_bytes[3] != lx_ecc_buffer[3]) ||
+          (ecc_bytes[4] != lx_ecc_buffer[4]) ||
+          (ecc_bytes[5] != lx_ecc_buffer[5]) ||
+          (ecc_bytes[6] != lx_ecc_buffer[6]) ||
+          (ecc_bytes[7] != lx_ecc_buffer[7]) ||  
+          (ecc_bytes[8] != lx_ecc_buffer[8]) ||  
+          (ecc_bytes[9] != lx_ecc_buffer[9]) ||
+          (ecc_bytes[10] != lx_ecc_buffer[10]) ||
+          (ecc_bytes[11] != lx_ecc_buffer[11]))
+      {
+         while(1)
+         {
+         }
+      }
+
+      /* Corrupt a bit in each ECC for 256 byte page.  */
+      if (ecc_bytes[1] & 1)
+          ecc_bytes[1] =  ecc_bytes[1] & 0xFE;
+      else
+          ecc_bytes[1] =  ecc_bytes[1] | 1;
+ 
+      if (ecc_bytes[4] & 1)
+          ecc_bytes[4] =  ecc_bytes[4] & 0xFE;
+      else
+          ecc_bytes[4] =  ecc_bytes[4] | 1;
+
+      if (ecc_bytes[7] & 1)
+          ecc_bytes[7] =  ecc_bytes[7] & 0xFE;
+      else
+          ecc_bytes[7] =  ecc_bytes[7] | 1;
+      
+      if (ecc_bytes[10] & 1)
+          ecc_bytes[10] =  ecc_bytes[10] & 0xFE;
+      else
+          ecc_bytes[10] =  ecc_bytes[10] | 1;
+      
+      if (ecc_bytes[13] & 1)
+          ecc_bytes[13] =  ecc_bytes[13] & 0xFE;
+      else
+          ecc_bytes[13] =  ecc_bytes[13] | 1;
+
+      if (ecc_bytes[16] & 1)
+          ecc_bytes[16] =  ecc_bytes[16] & 0xFE;
+      else
+          ecc_bytes[16] =  ecc_bytes[16] | 1;
+      
+      if (ecc_bytes[19] & 1)
+          ecc_bytes[19] =  ecc_bytes[19] & 0xFE;
+      else
+          ecc_bytes[19] =  ecc_bytes[19] | 1;
+
+      if (ecc_bytes[22] & 1)
+          ecc_bytes[22] =  ecc_bytes[22] & 0xFE;
+      else
+          ecc_bytes[22] =  ecc_bytes[22] | 1;
+     
+      
+      status =  (UINT) CorrectPageECC(byte_buffer, 2048, ecc_bytes);
+      if (status != 0)
+      {
+        
+          /* Check for corrected return value.  */
+          if (status != 1)
+          {
+            while(1)
+            {
+            }
+          }
+      }
+
+      /* Corrupt a bit in each ECC for 256 byte page.  */
+      if (lx_ecc_buffer[1] & 1)
+          lx_ecc_buffer[1] =  lx_ecc_buffer[1] & 0xFE;
+      else
+          lx_ecc_buffer[1] =  lx_ecc_buffer[1] | 1;
+ 
+      if (lx_ecc_buffer[4] & 1)
+          lx_ecc_buffer[4] =  lx_ecc_buffer[4] & 0xFE;
+      else
+          lx_ecc_buffer[4] =  lx_ecc_buffer[4] | 1;
+
+      if (lx_ecc_buffer[7] & 1)
+          lx_ecc_buffer[7] =  lx_ecc_buffer[7] & 0xFE;
+      else
+          lx_ecc_buffer[7] =  lx_ecc_buffer[7] | 1;
+      
+      if (lx_ecc_buffer[10] & 1)
+          lx_ecc_buffer[10] =  lx_ecc_buffer[10] & 0xFE;
+      else
+          lx_ecc_buffer[10] =  lx_ecc_buffer[10] | 1;
+      
+      if (lx_ecc_buffer[13] & 1)
+          lx_ecc_buffer[13] =  lx_ecc_buffer[13] & 0xFE;
+      else
+          lx_ecc_buffer[13] =  lx_ecc_buffer[13] | 1;
+
+      if (lx_ecc_buffer[16] & 1)
+          lx_ecc_buffer[16] =  lx_ecc_buffer[16] & 0xFE;
+      else
+          lx_ecc_buffer[16] =  lx_ecc_buffer[16] | 1;
+      
+      if (lx_ecc_buffer[19] & 1)
+          lx_ecc_buffer[19] =  lx_ecc_buffer[19] & 0xFE;
+      else
+          lx_ecc_buffer[19] =  lx_ecc_buffer[19] | 1;
+
+      if (lx_ecc_buffer[22] & 1)
+          lx_ecc_buffer[22] =  lx_ecc_buffer[22] & 0xFE;
+      else
+          lx_ecc_buffer[22] =  lx_ecc_buffer[22] | 1;
+     
+
+      
+      status =  lx_nand_flash_page_ecc_check(&nand_sim_flash, byte_buffer, lx_ecc_buffer);
+
+      if (status != LX_SUCCESS)
+      {
+        
+          /* Is it the corrected status?  */
+          if (status !=  LX_NAND_ERROR_CORRECTED)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+      }
+
+      /* Call LevelX ECC routines to create the ECC over the corrected buffer.  */
+      status =  lx_nand_flash_page_ecc_compute(&nand_sim_flash, byte_buffer, lx_ecc_buffer);
+
+      if (status != LX_SUCCESS)
+      {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+      }
+
+  }
+
+
+
+#endif
+ 
+  
+    
+#if 0
+/* TEST FileX packing routines.  */
+
+    /* Erase the simulated NAND flash.  */
+    _lx_nand_flash_simulator_erase_all();
+
+    /* Open the flash.  */    
+    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize);
+#ifdef EXTENDED_CACHE
+    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
+#endif
+    
+    if (status != LX_SUCCESS) 
+    {
+      
+          printf("FAILED!\n");
+          while(1)
+          {
+          }
+    }
+
+  /* Setup the write data.  */
+  for (i = 0; i < 8; i++)
+  {
+      for (j = 0; j < 512/4; j++)
+        test_write[i].words[j] = i;
+  }
+
+  /* Now write the data one logical sector at a time.  */
+  for (i = 0; i < 8; i++)
+  {
+       _fx_nand_flash_write_sectors(i, 1, (UCHAR *) &test_write[i]);
+  }
+
+  /* Setup the read buffer.  */
+  for (i = 0; i < 8; i++)
+  {
+      for (j = 0; j < 512/4; j++)
+        test_read[i].words[j] = 0xEFEFEFEF;
+  }
+
+  /* Read back in one sector at a time.  */
+  for (i = 0; i < 8; i++)
+  {
+       _fx_nand_flash_read_sectors(i, 1, (UCHAR *) &test_read[i].words[0]);
+  }
+  
+  /* Setup the read buffer.  */
+  for (i = 0; i < 8; i++)
+  {
+      for (j = 0; j < 512/4; j++)
+        test_read[i].words[j] = 0xEFEFEFEF;
+  }
+
+  _fx_nand_flash_read_sectors(3, 5, (UCHAR *) &test_read[3].words[0]);
+  _fx_nand_flash_read_sectors(1, 2, (UCHAR *) &test_read[1].words[0]);
+  _fx_nand_flash_read_sectors(0, 1, (UCHAR *) &test_read[0].words[0]);
+
+  /* Setup the read buffer.  */
+  for (i = 0; i < 8; i++)
+  {
+      for (j = 0; j < 512/4; j++)
+        test_read[i].words[j] = 0xEFEFEFEF;
+  }
+
+  _fx_nand_flash_read_sectors(0, 8, (UCHAR *) &test_read[0].words[0]);
+
+  
+    status =  lx_nand_flash_close(&nand_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+          while(1)
+          {
+          }
+    }
+
+    /* Erase the simulated NAND flash.  */
+    _lx_nand_flash_simulator_erase_all();
+
+    /* Open the flash.  */    
+    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize);
+#ifdef EXTENDED_CACHE
+    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
+#endif
+    
+    if (status != LX_SUCCESS) 
+    {
+      
+          printf("FAILED!\n");
+          while(1)
+          {
+          }
+    }
+
+    _fx_nand_flash_write_sectors(3, 5, (UCHAR *) &test_read[3].words[0]);
+    _fx_nand_flash_write_sectors(1, 2, (UCHAR *) &test_read[1].words[0]);
+    _fx_nand_flash_write_sectors(0, 1, (UCHAR *) &test_read[0].words[0]);
+
+    /* Setup the read buffer.  */
+    for (i = 0; i < 8; i++)
+    {
+      for (j = 0; j < 512/4; j++)
+          test_read[i].words[j] = 0xEFEFEFEF;
+    }
+
+    _fx_nand_flash_read_sectors(0, 1, (UCHAR *) &test_read[0].words[0]);
+    _fx_nand_flash_read_sectors(1, 2, (UCHAR *) &test_read[1].words[0]);
+    _fx_nand_flash_read_sectors(3, 5, (UCHAR *) &test_read[3].words[0]);
+
+    status =  lx_nand_flash_close(&nand_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+          while(1)
+          {
+          }
+    }
+
+  /* End */    
+#endif    
+    
+#ifdef BATCH_TEST
+    exit(0);
+#endif
+     /* All done!  */
+     while(1)
+     {
+     }
+}
+
+

test/regression/levelx_nor_flash_test.c

@@ -0,0 +1,1438 @@
+/* Basic NOR flash tests...  */
+
+#include <stdio.h>
+#include "lx_api.h"
+
+#define     DEMO_STACK_SIZE         4096
+
+
+/* Define the ThreadX object control blocks...  */
+#ifndef LX_STANDALONE_ENABLE
+TX_THREAD               thread_0;
+#endif
+UCHAR                   thread_0_stack[DEMO_STACK_SIZE];
+
+/* Define LevelX structures.  */
+
+LX_NOR_FLASH    nor_sim_flash;
+ULONG           buffer[128];
+ULONG           readbuffer[128];
+
+
+/* Define LevelX NOR flash simulator prototoypes.  */
+
+UINT  _lx_nor_flash_simulator_erase_all(VOID);
+UINT  _lx_nor_flash_simulator_initialize(LX_NOR_FLASH *nor_flash);
+
+
+
+/* Define thread prototypes.  */
+
+void    thread_0_entry(ULONG thread_input);
+
+
+
+/* Define main entry point.  */
+
+int main()
+{
+  
+    /* Enter the ThreadX kernel.  */
+#ifndef LX_STANDALONE_ENABLE
+    tx_kernel_enter();
+#else
+    thread_0_entry(0);
+#endif
+}
+
+
+/* Define what the initial system looks like.  */
+#ifndef LX_STANDALONE_ENABLE
+void    tx_application_define(void *first_unused_memory)
+{
+
+
+    /* Create the main thread.  */
+    tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0,  
+            thread_0_stack, DEMO_STACK_SIZE, 
+            1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);
+}
+#endif
+
+/* Define the test threads.  */
+
+void    thread_0_entry(ULONG thread_input)
+{
+
+ULONG   i, j, sector;
+UINT    status;
+
+ULONG   *word_ptr;
+
+  
+    /* Erase the simulated NOR flash.  */
+    _lx_nor_flash_simulator_erase_all();
+    
+    /* Initialize LevelX.  */
+    _lx_nor_flash_initialize();
+    
+    /* Test 1: Simple write 100 sectors and read 100 sectors.  */
+    printf("Test 1: Simple write-read 100 sectors...........");
+    
+    lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+    
+    /* Write 100 sectors....  */
+    for (i = 0; i < 100; i++)
+    {
+        for (j = 0; j < 128; j++)
+          buffer[j] =  i;
+        
+        status =  lx_nor_flash_sector_write(&nor_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+    
+    /* Read back 100 sectors...  */
+    for (i = 0; i < 100; i++)
+    {
+        
+        status =  lx_nor_flash_sector_read(&nor_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if (buffer[j] !=  i)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+    }
+
+    _lx_nor_flash_close(&nor_sim_flash);
+    printf("SUCCESS!\n");
+
+    /* Test 2: Write same sector 120 times.  */
+    printf("Test 2: Write same sector 120 times.............");
+    
+    /* Reinitialize...  */    
+    _lx_nor_flash_simulator_erase_all();
+    
+    
+    lx_nor_flash_initialize();
+    lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+
+    for (j = 0; j < 128; j++)
+         buffer[j] =  0xFFFFFFFF;
+    
+    /* Write same sector 120 sectors....  */
+    for (i = 0; i < 120; i++)
+    {
+        for (j = 0; j < 128; j++)
+          buffer[j] =  i;
+      
+        status =  lx_nor_flash_sector_write(&nor_sim_flash, 7, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        status =  lx_nor_flash_sector_read(&nor_sim_flash, 7, readbuffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if (buffer[j] !=  readbuffer[j])
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+        
+        /* Write other sectors just to have additional sectors to manage.  */
+        if (i == 1)
+          lx_nor_flash_sector_write(&nor_sim_flash, 1, buffer);
+        if (i == 16)
+          lx_nor_flash_sector_write(&nor_sim_flash, 16, buffer);
+        if (i == 32)
+          lx_nor_flash_sector_write(&nor_sim_flash, 32, buffer);
+        if (i == 48)
+          lx_nor_flash_sector_write(&nor_sim_flash, 48, buffer);
+        if (i == 64)
+          lx_nor_flash_sector_write(&nor_sim_flash, 64, buffer);
+        if (i == 80)
+          lx_nor_flash_sector_write(&nor_sim_flash, 80, buffer);
+        if (i == 96)
+          lx_nor_flash_sector_write(&nor_sim_flash, 96, buffer);
+        if (i == 112)
+          lx_nor_flash_sector_write(&nor_sim_flash, 112, buffer);
+    }
+
+    status =  lx_nor_flash_defragment(&nor_sim_flash);
+
+    
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nor_flash_sector_read(&nor_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+
+    status =  lx_nor_flash_defragment(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+   
+    
+    /* Point at the simulated NOR flash memory.  */
+    word_ptr =  nor_sim_flash.lx_nor_flash_base_address;
+    
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    printf("SUCCESS!\n");
+   
+    /* Test 3: Corrupt block 0, simulate a power interruption during erase of block 0, 
+       after the erase, but before the free bit map and erase count is setup.  */
+    printf("Test 3: Block erase-initialize interrupted......");
+    word_ptr[0] =  0xFFFFFFFF;
+    word_ptr[3] =  0xFFFFFFFF;
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 111) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+   
+    /* Corrupt block 0, simulate a power interruption during erase of block 0, 
+       after the erase, and after the free bit map setup, but before erase count is setup.  */
+    word_ptr[0] =  0xFFFFFFFF;
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 111) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    printf("SUCCESS!\n");
+
+    /* Test 4: simulate a power interruption after a new block is allocated but before
+       anything else can be done.  */
+    printf("Test 4: Power interrupted new block allocation..");
+    word_ptr[3] =  word_ptr[3] & ~((ULONG) 1);
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 110) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    /* Simulate a power interruption after a new block is allocated but before
+       anything else can be done.  */
+    word_ptr[(16*128)+3] =  0x7C00;
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 109) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    /* Simulate a power interruption after a new sector is allocated, after data
+       had been copied, and the superceeded bit is clear, but before the new entry can be
+       setup.  */
+    word_ptr[3] =  0x7FFC;
+    word_ptr[(16*128)+6] =  word_ptr[(16*128)+6] & ~((ULONG) 0x40000000);
+    
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 108) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    lx_nor_flash_close(&nor_sim_flash);
+    
+    /* Simulate a power interruption after a new sector is allocated, after data
+       had been copied, and the superceeded bit is clear, the new entry is setup, but the old entry
+       has not been invalidated.  */
+    word_ptr[3] =  0x7FF8;
+    word_ptr[6] =  0xC0000070;
+    for (i = 0; i < 128; i++)
+    {
+        word_ptr[(3*128)+i] =  0x70;
+    }
+    
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 107) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nor_flash_sector_read(&nor_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+
+    status =  lx_nor_flash_defragment(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+   
+    status =  lx_nor_flash_defragment(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nor_flash_sector_read(&nor_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+
+    /* Read in reverse order to see if caching helps!  */
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nor_flash_sector_read(&nor_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+    status =  lx_nor_flash_sector_release(&nor_sim_flash, 7);
+    if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_release(&nor_sim_flash, 8);
+    if (status != LX_SECTOR_NOT_FOUND)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+    status =  lx_nor_flash_defragment(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nor_flash_close(&nor_sim_flash);
+
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+   
+    printf("SUCCESS!\n");
+
+    printf("Test 5: Randow write/read sector................");
+
+    /* Erase the simulated NOR flash.  */
+    _lx_nor_flash_simulator_erase_all();
+
+    /* Open the flash.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+
+    if (status != LX_SUCCESS) 
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    /* Write 100 sectors....  */
+    for (i = 0; i < 100; i++)
+    {
+        for (j = 0; j < 128; j++)
+          buffer[j] =  i;
+        
+        status =  lx_nor_flash_sector_write(&nor_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+    
+    /* Read back 100 sectors...  */
+    for (i = 0; i < 100; i++)
+    {
+        
+        status =  lx_nor_flash_sector_read(&nor_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if (buffer[j] !=  i)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+    }
+    
+    /* Now, perform 1000 sector writes to randomly selected sectors, each time
+       reading first to make sure the previous contents are valid.  */
+    for (i = 0; i < 1000; i++)
+    {
+    
+        /* Pickup random sector.  */
+        sector =  (rand() % 100);
+
+        /* Read that sector.  */
+        status =  lx_nor_flash_sector_read(&nor_sim_flash, sector, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if ((buffer[j] & 0x0000FFFF) !=  sector)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+
+        /* Include the itteraction in the buffer to generate a new write.  */
+        for (j = 0; j < 128; j++)
+        {
+ 
+            buffer[j] =  (buffer[j] & 0x0000FFFF) | (i << 16);
+        }
+        
+        status =  lx_nor_flash_sector_write(&nor_sim_flash, sector, buffer);
+
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+    
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    printf("SUCCESS!\n");
+#ifdef BATCH_TEST
+    exit(0);
+#endif
+
+     /* All done!  */
+     while(1)
+     {
+     }
+}
+
+

test/regression/levelx_nor_flash_test_cache.c

@@ -0,0 +1,1664 @@
+/* Basic NOR flash tests...  */
+
+#include <stdio.h>
+#include "lx_api.h"
+
+#define     DEMO_STACK_SIZE         4096
+
+
+/* Define the ThreadX object control blocks...  */
+#ifndef LX_STANDALONE_ENABLE
+TX_THREAD               thread_0;
+#endif
+UCHAR                   thread_0_stack[DEMO_STACK_SIZE];
+
+/* Define LevelX structures.  */
+
+LX_NOR_FLASH    nor_sim_flash;
+ULONG           buffer[128];
+ULONG           readbuffer[128];
+
+UCHAR   nor_cache_memory[2048+16+8];
+UCHAR   nor_cache_memory2[8192];
+
+
+/* Define LevelX NOR flash simulator prototoypes.  */
+
+UINT  _lx_nor_flash_simulator_erase_all(VOID);
+UINT  _lx_nor_flash_simulator_initialize(LX_NOR_FLASH *nor_flash);
+
+
+
+/* Define thread prototypes.  */
+
+void    thread_0_entry(ULONG thread_input);
+
+
+
+/* Define main entry point.  */
+
+int main()
+{
+  
+    /* Enter the ThreadX kernel.  */
+#ifndef LX_STANDALONE_ENABLE
+    tx_kernel_enter();
+#else
+    thread_0_entry(0);
+#endif
+
+}
+
+
+/* Define what the initial system looks like.  */
+#ifndef LX_STANDALONE_ENABLE
+void    tx_application_define(void *first_unused_memory)
+{
+
+
+    /* Create the main thread.  */
+    tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0,  
+            thread_0_stack, DEMO_STACK_SIZE, 
+            1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);
+}
+#endif
+
+/* Define the test threads.  */
+
+void    thread_0_entry(ULONG thread_input)
+{
+
+ULONG   i, j, sector;
+UINT    status;
+
+ULONG   *word_ptr;
+
+  
+    /* Erase the simulated NOR flash.  */
+    _lx_nor_flash_simulator_erase_all();
+    
+    /* Initialize LevelX.  */
+    _lx_nor_flash_initialize();
+    
+    /* Test 1: Simple write 100 sectors and read 100 sectors.  */
+    printf("Test 1: Simple write-read 100 sectors...........");
+    
+    lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+#ifndef LX_NOR_DISABLE_EXTENDED_CACHE
+lx_nor_flash_extended_cache_enable(&nor_sim_flash, nor_cache_memory, sizeof(nor_cache_memory));
+#endif
+#ifdef LX_NOR_ENABLE_MAPPING_BITMAP
+    if (nor_sim_flash.lx_nor_flash_extended_cache_mapping_bitmap_max_logical_sector != 128)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+#endif
+#ifdef LX_NOR_ENABLE_OBSOLETE_COUNT_CACHE
+
+    if (nor_sim_flash.lx_nor_flash_extended_cache_obsolete_count_max_block != 8)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+#endif
+
+    /* Write 100 sectors....  */
+    for (i = 0; i < 100; i++)
+    {
+        for (j = 0; j < 128; j++)
+          buffer[j] =  i;
+        
+        status =  lx_nor_flash_sector_write(&nor_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+    
+    /* Read back 100 sectors...  */
+    for (i = 0; i < 100; i++)
+    {
+        
+        status =  lx_nor_flash_sector_read(&nor_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if (buffer[j] !=  i)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+    }
+#ifdef LX_NOR_ENABLE_MAPPING_BITMAP
+    for (i = 0; i < 100; i++)
+    {
+        if (nor_sim_flash.lx_nor_flash_extended_cache_mapping_bitmap[i>>5] & (ULONG)(1<<(i & 31)) == 0)
+        {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+        }
+    }
+#endif
+
+#ifdef LX_NOR_ENABLE_OBSOLETE_COUNT_CACHE
+    for (i = 0; i < 8; i++)
+    {
+        if(nor_sim_flash.lx_nor_flash_extended_cache_obsolete_count[i] != 0)
+        {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+        }
+
+    }
+#endif
+
+    /* Release 100 sectors...  */
+    for (i = 0; i < 100; i++)
+    {
+        
+        status =  lx_nor_flash_sector_release(&nor_sim_flash, i);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+
+#ifdef LX_NOR_ENABLE_MAPPING_BITMAP
+    for (i = 0; i < 100; i++)
+    {
+        if (nor_sim_flash.lx_nor_flash_extended_cache_mapping_bitmap[i>>5] & (ULONG)(1<<(i & 31)) != 0)
+        {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+        }
+    }
+#endif
+
+#ifdef LX_NOR_ENABLE_OBSOLETE_COUNT_CACHE
+    for (i = 0; i < 6; i++)
+    {
+        if(nor_sim_flash.lx_nor_flash_extended_cache_obsolete_count[i] != 15)
+        {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+        }
+
+    }
+    if (nor_sim_flash.lx_nor_flash_extended_cache_obsolete_count[6] != 10 || nor_sim_flash.lx_nor_flash_extended_cache_obsolete_count[7] != 0)
+    {
+        printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+        while(1)
+        {
+        }
+    }
+#endif
+
+
+    _lx_nor_flash_close(&nor_sim_flash);
+    printf("SUCCESS!\n");
+
+    /* Test 2: Write same sector 120 times.  */
+    printf("Test 2: Write same sector 120 times.............");
+    
+    /* Reinitialize...  */    
+    _lx_nor_flash_simulator_erase_all();
+    
+    
+    lx_nor_flash_initialize();
+    lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+#ifndef LX_NOR_DISABLE_EXTENDED_CACHE
+lx_nor_flash_extended_cache_enable(&nor_sim_flash, nor_cache_memory, sizeof(nor_cache_memory));
+#endif
+
+    for (j = 0; j < 128; j++)
+         buffer[j] =  0xFFFFFFFF;
+    
+    /* Write same sector 120 sectors....  */
+    for (i = 0; i < 120; i++)
+    {
+        for (j = 0; j < 128; j++)
+          buffer[j] =  i;
+      
+        status =  lx_nor_flash_sector_write(&nor_sim_flash, 7, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        status =  lx_nor_flash_sector_read(&nor_sim_flash, 7, readbuffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if (buffer[j] !=  readbuffer[j])
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+        
+        /* Write other sectors just to have additional sectors to manage.  */
+        if (i == 1)
+          lx_nor_flash_sector_write(&nor_sim_flash, 1, buffer);
+        if (i == 16)
+          lx_nor_flash_sector_write(&nor_sim_flash, 16, buffer);
+        if (i == 32)
+          lx_nor_flash_sector_write(&nor_sim_flash, 32, buffer);
+        if (i == 48)
+          lx_nor_flash_sector_write(&nor_sim_flash, 48, buffer);
+        if (i == 64)
+          lx_nor_flash_sector_write(&nor_sim_flash, 64, buffer);
+        if (i == 80)
+          lx_nor_flash_sector_write(&nor_sim_flash, 80, buffer);
+        if (i == 96)
+          lx_nor_flash_sector_write(&nor_sim_flash, 96, buffer);
+        if (i == 112)
+          lx_nor_flash_sector_write(&nor_sim_flash, 112, buffer);
+    }
+
+    status =  lx_nor_flash_defragment(&nor_sim_flash);
+
+    
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nor_flash_sector_read(&nor_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+
+    status =  lx_nor_flash_defragment(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+   
+    
+    /* Point at the simulated NOR flash memory.  */
+    word_ptr =  nor_sim_flash.lx_nor_flash_base_address;
+    
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    printf("SUCCESS!\n");
+   
+    /* Test 3: Corrupt block 0, simulate a power interruption during erase of block 0, 
+       after the erase, but before the free bit map and erase count is setup.  */
+    printf("Test 3: Block erase-initialize interrupted......");
+    word_ptr[0] =  0xFFFFFFFF;
+    word_ptr[3] =  0xFFFFFFFF;
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+#ifndef LX_NOR_DISABLE_EXTENDED_CACHE
+status += lx_nor_flash_extended_cache_enable(&nor_sim_flash, nor_cache_memory, sizeof(nor_cache_memory));
+#endif
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 111) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+   
+    /* Corrupt block 0, simulate a power interruption during erase of block 0, 
+       after the erase, and after the free bit map setup, but before erase count is setup.  */
+    word_ptr[0] =  0xFFFFFFFF;
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+#ifndef LX_NOR_DISABLE_EXTENDED_CACHE
+status += lx_nor_flash_extended_cache_enable(&nor_sim_flash, nor_cache_memory, sizeof(nor_cache_memory));
+#endif
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 111) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    printf("SUCCESS!\n");
+
+    /* Test 4: simulate a power interruption after a new block is allocated but before
+       anything else can be done.  */
+    printf("Test 4: Power interrupted new block allocation..");
+    word_ptr[3] =  word_ptr[3] & ~((ULONG) 1);
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+#ifndef LX_NOR_DISABLE_EXTENDED_CACHE
+status += lx_nor_flash_extended_cache_enable(&nor_sim_flash, nor_cache_memory, sizeof(nor_cache_memory));
+#endif
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 110) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    /* Simulate a power interruption after a new block is allocated but before
+       anything else can be done.  */
+    word_ptr[(16*128)+3] =  0x7C00;
+
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+#ifndef LX_NOR_DISABLE_EXTENDED_CACHE
+status += lx_nor_flash_extended_cache_enable(&nor_sim_flash, nor_cache_memory, sizeof(nor_cache_memory));
+#endif
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 109) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    /* Simulate a power interruption after a new sector is allocated, after data
+       had been copied, and the superceeded bit is clear, but before the new entry can be
+       setup.  */
+    word_ptr[3] =  0x7FFC;
+    word_ptr[(16*128)+6] =  word_ptr[(16*128)+6] & ~((ULONG) 0x40000000);
+    
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+#ifndef LX_NOR_DISABLE_EXTENDED_CACHE
+status += lx_nor_flash_extended_cache_enable(&nor_sim_flash, nor_cache_memory, sizeof(nor_cache_memory));
+#endif
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 108) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    lx_nor_flash_close(&nor_sim_flash);
+    
+    /* Simulate a power interruption after a new sector is allocated, after data
+       had been copied, and the superceeded bit is clear, the new entry is setup, but the old entry
+       has not been invalidated.  */
+    word_ptr[3] =  0x7FF8;
+    word_ptr[6] =  0xC0000070;
+    for (i = 0; i < 128; i++)
+    {
+        word_ptr[(3*128)+i] =  0x70;
+    }
+    
+    /* Open the flash and see if we recover properly.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+#ifndef LX_NOR_DISABLE_EXTENDED_CACHE
+status += lx_nor_flash_extended_cache_enable(&nor_sim_flash, nor_cache_memory, sizeof(nor_cache_memory));
+#endif
+
+    if ((status != LX_SUCCESS) ||
+        (nor_sim_flash.lx_nor_flash_free_physical_sectors != 107) ||
+        (nor_sim_flash.lx_nor_flash_mapped_physical_sectors != 9))
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nor_flash_sector_read(&nor_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+
+    status =  lx_nor_flash_defragment(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+   
+    status =  lx_nor_flash_defragment(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nor_flash_sector_read(&nor_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+
+    /* Read in reverse order to see if caching helps!  */
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 112, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 112)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 96, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 96)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+     status =  lx_nor_flash_sector_read(&nor_sim_flash, 80, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 80)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 64, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 64)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 48, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 48)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 32, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 32)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 16, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 16)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 1, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 1)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_read(&nor_sim_flash, 7, readbuffer);
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        if (readbuffer[0] != 119)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+    status =  lx_nor_flash_sector_release(&nor_sim_flash, 7);
+    if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    status =  lx_nor_flash_sector_release(&nor_sim_flash, 8);
+    if (status != LX_SECTOR_NOT_FOUND)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+    status =  lx_nor_flash_defragment(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    status =  lx_nor_flash_close(&nor_sim_flash);
+
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+   
+    printf("SUCCESS!\n");
+
+    printf("Test 5: Randow write/read sector................");
+
+    /* Erase the simulated NOR flash.  */
+    _lx_nor_flash_simulator_erase_all();
+
+    /* Open the flash.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+#ifndef LX_NOR_DISABLE_EXTENDED_CACHE
+status += lx_nor_flash_extended_cache_enable(&nor_sim_flash, nor_cache_memory, sizeof(nor_cache_memory));
+#endif
+
+    if (status != LX_SUCCESS) 
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    
+    /* Write 100 sectors....  */
+    for (i = 0; i < 100; i++)
+    {
+        for (j = 0; j < 128; j++)
+          buffer[j] =  i;
+        
+        status =  lx_nor_flash_sector_write(&nor_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+    
+    /* Read back 100 sectors...  */
+    for (i = 0; i < 100; i++)
+    {
+        
+        status =  lx_nor_flash_sector_read(&nor_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if (buffer[j] !=  i)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+    }
+    
+    /* Now, perform 1000 sector writes to randomly selected sectors, each time
+       reading first to make sure the previous contents are valid.  */
+    for (i = 0; i < 1000; i++)
+    {
+    
+        /* Pickup random sector.  */
+        sector =  (rand() % 100);
+
+        /* Read that sector.  */
+        status =  lx_nor_flash_sector_read(&nor_sim_flash, sector, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if ((buffer[j] & 0x0000FFFF) !=  sector)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+
+        /* Include the itteraction in the buffer to generate a new write.  */
+        for (j = 0; j < 128; j++)
+        {
+ 
+            buffer[j] =  (buffer[j] & 0x0000FFFF) | (i << 16);
+        }
+        
+        status =  lx_nor_flash_sector_write(&nor_sim_flash, sector, buffer);
+
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+    
+    status =  lx_nor_flash_close(&nor_sim_flash);
+    
+    if (status != LX_SUCCESS)
+    {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+    printf("SUCCESS!\n");
+
+    printf("Test 6: Check lx_nor_flash_extended_cache_entries size................");
+
+    /* Erase the simulated NOR flash.  */
+    _lx_nor_flash_simulator_erase_all();
+
+    /* Open the flash.  */    
+    status =  lx_nor_flash_open(&nor_sim_flash, "sim nor flash", _lx_nor_flash_simulator_initialize);
+#ifndef LX_NOR_DISABLE_EXTENDED_CACHE
+status += lx_nor_flash_extended_cache_enable(&nor_sim_flash, nor_cache_memory2, sizeof(nor_cache_memory2));
+#endif
+
+    if (status != LX_SUCCESS) 
+    {
+      
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+    }
+
+    /* Write 100 sectors....  */
+    for (i = 0; i < 100; i++)
+    {
+        for (j = 0; j < 128; j++)
+          buffer[j] =  i;
+        
+        status =  lx_nor_flash_sector_write(&nor_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+    }
+    
+    /* Read back 100 sectors...  */
+    for (i = 0; i < 100; i++)
+    {
+        
+        status =  lx_nor_flash_sector_read(&nor_sim_flash, i, buffer);
+      
+        if (status != LX_SUCCESS)
+        {
+          printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+          while(1)
+          {
+          }
+        }
+        
+        for (j = 0; j < 128; j++)
+        {
+          
+          if (buffer[j] !=  i)
+          {
+            printf("FAILED!\n");
+#ifdef BATCH_TEST
+    exit(1);
+#endif
+            while(1)
+            {
+            }
+          }
+        }
+    }
+    
+#ifdef BATCH_TEST
+    exit(0);
+#endif
+     /* All done!  */
+     while(1)
+     {
+     }
+}
+
+