BOOL LoadNslData(const char *pszOemFileName,const char *pszAnsiName,const char *pszLanguageFileName,unsigned short **ppOemFileData,unsigned short **ppAnsiFileData,unsigned short **ppLangFileData)
{
   int OemFileHandle;
   int OemFileSize;
   int OemAllocSize;
   int AnsiFileHandle;
   int AnsiFileSize;
   int AnsiAllocSize;
   int LangFileHandle;
   int LangFileSize;
   int LangAllocSize;
   int NlsTableDataSize;
   byte *pNlsData;
   BOOL bRet;

   bRet = FALSE;
   OemFileHandle = _open(pszOemFileName,_O_RDONLY|_O_BINARY);
   if (OemFileHandle != -1)
   {
      AnsiFileHandle = _open(pszAnsiName,_O_RDONLY|_O_BINARY);
      if (AnsiFileHandle != -1)
      {
         LangFileHandle = _open(pszLanguageFileName,_O_RDONLY|_O_BINARY);
         if (LangFileHandle != -1)
         {
            OemFileSize   = _filelength(OemFileHandle);
            OemAllocSize  = ((OemFileSize) + 0xFFF) & 0xFFFFF000;
            AnsiFileSize  = _filelength(AnsiFileHandle);
            AnsiAllocSize = ((AnsiFileSize) + 0xFFF) & 0xFFFFF000;
            LangFileSize  = _filelength(LangFileHandle);
            LangAllocSize = ((LangFileSize) + 0xFFF) & 0xFFFFF000;
            NlsTableDataSize = OemAllocSize+AnsiAllocSize+LangAllocSize;
            pNlsData = malloc(NlsTableDataSize);
            if (pNlsData!=NULL)
            {
               memset(pNlsData,0,NlsTableDataSize);
               _read(OemFileHandle,(void*)&pNlsData[0],OemFileSize);
               _read(AnsiFileHandle,(void*)&pNlsData[OemAllocSize],AnsiFileSize);
               _read(LangFileHandle,(void*)&pNlsData[OemAllocSize+AnsiAllocSize],LangFileSize);
               *ppOemFileData = (unsigned short*) &pNlsData[0];
               *ppAnsiFileData = (unsigned short*) &pNlsData[OemAllocSize];
               *ppLangFileData = (unsigned short*) &pNlsData[OemAllocSize+AnsiAllocSize];
               bRet = TRUE;
            }
            _close(LangFileHandle);
         }
         _close(AnsiFileHandle);
      }

      _close(OemFileHandle);
   }
   return bRet;
}


BOOL ROSTEST_RtlUpcaseUnicodeStringToCountedOemString(fnRtlUpcaseUnicodeStringToCountedOemString ppfnRtlUpcaseUnicodeStringToCountedOemString)
{
   NTSTATUS Status;
   UNICODE_STRING TestUniocodeString;
   OEM_STRING TestOemString;
   CHAR TestBuffer[128];
   NLSTABLEINFO TableInfo;
   char OemFileName[MAX_PATH];
   char AnsiFileName[MAX_PATH];
   char LangFileName[MAX_PATH];
   char WinRootPath[MAX_PATH];
   PUSHORT pOemFileData;
   PUSHORT pAnsiFileData;
   PUSHORT pLangFileData;



   TestOemString.Length = sizeof(TestBuffer)-1;
   TestOemString.MaximumLength = sizeof(TestBuffer);
   TestOemString.Buffer = TestBuffer;

   sprintf(WinRootPath,"C:\\Windows\\System32\\");
   sprintf(OemFileName,"%s%s",WinRootPath,"c_437.nls");
   sprintf(AnsiFileName,"%s%s",WinRootPath,"c_1252.nls");
   sprintf(LangFileName,"%s%s",WinRootPath,"l_intl.nls");



   if (LoadNslData(OemFileName,AnsiFileName,LangFileName,&pOemFileData,&pAnsiFileData,&pLangFileData) == TRUE)
   {
      /* First let test the normal case */

      printf("test unpatch version\n");

      /* set the unicode string to the default mapped character "?" in this codepage */
      pfnRtlInitUnicodeString(&TestUniocodeString,L"?");

      Status = pfnRtlUpcaseUnicodeToOemN(TestOemString.Buffer,TestOemString.MaximumLength,NULL,TestUniocodeString.Buffer,TestUniocodeString.MaximumLength);
      if (Status == STATUS_SUCCESS)
      {
         Status = ppfnRtlUpcaseUnicodeStringToCountedOemString(&TestOemString,(PCUNICODE_STRING)&TestUniocodeString,FALSE);
         if (Status == STATUS_UNMAPPABLE_CHARACTER)
         {
            printf("Unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
         else
         {
            printf("No unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
      }

      /* free the string */
      pfnRtlFreeUnicodeString(&TestUniocodeString);

      /* everything works fine and the unicode (0x1212) -> CP give us an "?" */
      pfnRtlInitUnicodeString(&TestUniocodeString,L"\x1212");
      Status = pfnRtlUpcaseUnicodeToOemN(TestOemString.Buffer,TestOemString.MaximumLength,NULL,TestUniocodeString.Buffer,TestUniocodeString.MaximumLength);
      
      if (Status == STATUS_SUCCESS)
      {
         /* Use the function */
         Status = ppfnRtlUpcaseUnicodeStringToCountedOemString(&TestOemString,(PCUNICODE_STRING)&TestUniocodeString,FALSE);
         if (Status == STATUS_UNMAPPABLE_CHARACTER)
         {
            printf("Unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
         else
         {
            printf("No unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
      }



      printf("\n\n");
      printf("test with DefaultChar for unmappable character\n");

      /* now with a new loaded default Windows codepage */
      pfnRtlInitNlsTables(pOemFileData,pAnsiFileData,pLangFileData,&TableInfo);
      /* set the codepages */
      pfnRtlResetRtlTranslations(&TableInfo);

      Status = pfnRtlUpcaseUnicodeToOemN(TestOemString.Buffer,TestOemString.MaximumLength,NULL,TestUniocodeString.Buffer,TestUniocodeString.MaximumLength);
      
      if (Status == STATUS_SUCCESS)
      {
         /* Use the function */
         Status = ppfnRtlUpcaseUnicodeStringToCountedOemString(&TestOemString,(PCUNICODE_STRING)&TestUniocodeString,FALSE);
         if (Status == STATUS_UNMAPPABLE_CHARACTER)
         {
            printf("Unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
         else
         {
            printf("No unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
      }
      
      printf("set other default for the test.\n");

      /* patch the DefaultChar with the letter 'A' */
      TableInfo.OemTableInfo.DefaultChar = 'A';
      pfnRtlResetRtlTranslations(&TableInfo);

      Status = pfnRtlUpcaseUnicodeToOemN(TestOemString.Buffer,TestOemString.MaximumLength,NULL,TestUniocodeString.Buffer,TestUniocodeString.MaximumLength);
      if (Status == STATUS_SUCCESS)
      {
         Status = ppfnRtlUpcaseUnicodeStringToCountedOemString(&TestOemString,(PCUNICODE_STRING)&TestUniocodeString,FALSE);
         if (Status == STATUS_UNMAPPABLE_CHARACTER)
         {
            printf("Unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
         else
         {
            printf("No unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
      }

      /* back to the real default */
      TableInfo.OemTableInfo.DefaultChar = 0x3F;
      pfnRtlResetRtlTranslations(&TableInfo);

      printf("test with TransDefaultChar for unmappable character\n");

      pfnRtlInitNlsTables(pOemFileData,pAnsiFileData,pLangFileData,&TableInfo);
      pfnRtlResetRtlTranslations(&TableInfo);
      
      /* set the unicode string to an unmappable character */
      pfnRtlInitUnicodeString(&TestUniocodeString,L"\x1212");
      
      Status = pfnRtlUpcaseUnicodeToOemN(TestOemString.Buffer,TestOemString.MaximumLength,NULL,TestUniocodeString.Buffer,TestUniocodeString.MaximumLength);
      
      if (Status == STATUS_SUCCESS)
      {
         /* Use the function */
         Status = ppfnRtlUpcaseUnicodeStringToCountedOemString(&TestOemString,(PCUNICODE_STRING)&TestUniocodeString,FALSE);
         if (Status == STATUS_UNMAPPABLE_CHARACTER)
         {
            printf("Unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
         else
         {
            printf("No unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
      }
      
      printf("set other default for the test.\n");

      /* now with TransDefaultChar */
      TableInfo.OemTableInfo.TransDefaultChar = 'A';
      pfnRtlResetRtlTranslations(&TableInfo);

      Status = pfnRtlUpcaseUnicodeToOemN(TestOemString.Buffer,TestOemString.MaximumLength,NULL,TestUniocodeString.Buffer,TestUniocodeString.MaximumLength);
      if (Status == STATUS_SUCCESS)
      {
         Status = ppfnRtlUpcaseUnicodeStringToCountedOemString(&TestOemString,(PCUNICODE_STRING)&TestUniocodeString,FALSE);
         if (Status == STATUS_UNMAPPABLE_CHARACTER)
         {
            printf("Unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
         else
         {
            printf("No unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
      }

      /* back to the real default */
      TableInfo.OemTableInfo.TransDefaultChar = 0x3F;
      pfnRtlResetRtlTranslations(&TableInfo);

      /* free the string */
      pfnRtlFreeUnicodeString(&TestUniocodeString);


      printf("test for UniDefaultChar with a mappable character '?' \n");

      /* set the unicode string to the default mapped character "?" in this codepage */
      pfnRtlInitUnicodeString(&TestUniocodeString,L"?");

      Status = pfnRtlUpcaseUnicodeToOemN(TestOemString.Buffer,TestOemString.MaximumLength,NULL,TestUniocodeString.Buffer,TestUniocodeString.MaximumLength);
      if (Status == STATUS_SUCCESS)
      {
         Status = ppfnRtlUpcaseUnicodeStringToCountedOemString(&TestOemString,(PCUNICODE_STRING)&TestUniocodeString,FALSE);
         if (Status == STATUS_UNMAPPABLE_CHARACTER)
         {
            printf("Unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
         else
         {
            printf("No unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
      }

      printf("set other default for the test.\n");

      TableInfo.OemTableInfo.TransDefaultChar = 'A';
      pfnRtlResetRtlTranslations(&TableInfo);

      Status = pfnRtlUpcaseUnicodeToOemN(TestOemString.Buffer,TestOemString.MaximumLength,NULL,TestUniocodeString.Buffer,TestUniocodeString.MaximumLength);
      if (Status == STATUS_SUCCESS)
      {
         Status = ppfnRtlUpcaseUnicodeStringToCountedOemString(&TestOemString,(PCUNICODE_STRING)&TestUniocodeString,FALSE);
         if (Status == STATUS_UNMAPPABLE_CHARACTER)
         {
            printf("Unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
         else
         {
            printf("No unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
      }

      /* back to the default */
      TableInfo.OemTableInfo.TransDefaultChar = 0x3F;
      pfnRtlResetRtlTranslations(&TableInfo);

      printf("test for TransUniDefaultChar with a mappable character '?' \n");

      /* set the unicode string to the default mapped character "?" in this codepage */
      pfnRtlInitUnicodeString(&TestUniocodeString,L"?");

      Status = pfnRtlUpcaseUnicodeToOemN(TestOemString.Buffer,TestOemString.MaximumLength,NULL,TestUniocodeString.Buffer,TestUniocodeString.MaximumLength);
      if (Status == STATUS_SUCCESS)
      {
         Status = ppfnRtlUpcaseUnicodeStringToCountedOemString(&TestOemString,(PCUNICODE_STRING)&TestUniocodeString,FALSE);
         if (Status == STATUS_UNMAPPABLE_CHARACTER)
         {
            printf("Unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
         else
         {
            printf("No unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
      }

      TableInfo.OemTableInfo.TransUniDefaultChar = 'A';
      pfnRtlResetRtlTranslations(&TableInfo);

      Status = pfnRtlUpcaseUnicodeToOemN(TestOemString.Buffer,TestOemString.MaximumLength,NULL,TestUniocodeString.Buffer,TestUniocodeString.MaximumLength);
      if (Status == STATUS_SUCCESS)
      {
         Status = ppfnRtlUpcaseUnicodeStringToCountedOemString(&TestOemString,(PCUNICODE_STRING)&TestUniocodeString,FALSE);
         if (Status == STATUS_UNMAPPABLE_CHARACTER)
         {
            printf("Unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
         else
         {
            printf("No unmappable character 0x%x\n",TestOemString.Buffer[0]);
         }
      }

      /* free the string */
      pfnRtlFreeUnicodeString(&TestUniocodeString);

   }

   return FALSE;
}

#ifdef TESTRESULT
// test results

test unpatch version
No unmappable character 0x3f
Unmappable character 0x3f


test with DefaultChar for unmappable character
Unmappable character 0x3f
set other default for the test.
No unmappable character 0x3f
test with TransDefaultChar for unmappable character
Unmappable character 0x3f
set other default for the test.
Unmappable character 0x3f
test for UniDefaultChar with a mappable character '?'
No unmappable character 0x3f
set other default for the test.
Unmappable character 0x3f
test for TransUniDefaultChar with a mappable character '?'
No unmappable character 0x3f
No unmappable character 0x3f

#endif // TESTRESULT