Lump client and server versions of Windows together.

base/win/pe_image_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file contains unit tests for PEImage.
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "base/win/pe_image.h"
 #include "base/win/windows_version.h"
 
@@ skipping 65 matching lines @@
                                PIMAGE_THUNK_DATA name_table,
                                PIMAGE_THUNK_DATA iat,
                                PIMAGE_THUNK_DATA bound_iat,
                                PIMAGE_THUNK_DATA unload_iat,
                                PVOID cookie) {
   int* count = reinterpret_cast<int*>(cookie);
   (*count)++;
   return true;
 }
 
+// Identifiers for the set of supported expectations.
+enum ExpectationSet {
+  WIN_2K_SET,
+  WIN_XP_SET,
+  WIN_VISTA_SET,
+  WIN_7_SET,
+  WIN_8_SET,
+  UNSUPPORTED_SET,
+};
+
 // We'll be using some known values for the tests.
 enum Value {
   sections = 0,
   imports_dlls,
   delay_dlls,
   exports,
   imports,
   delay_imports,
   relocs
 };
 
+ExpectationSet GetExpectationSet(DWORD os) {
+  if (os == 50)
+    return WIN_2K_SET;
+  if (os == 51)
+    return WIN_XP_SET;
+  if (os == 60)
+    return WIN_VISTA_SET;
+  if (os == 61)
+    return WIN_7_SET;
+  if (os >= 62)
+    return WIN_8_SET;
+  return UNSUPPORTED_SET;
+}
+
 // Retrieves the expected value from advapi32.dll based on the OS.
 int GetExpectedValue(Value value, DWORD os) {
   const int xp_delay_dlls = 2;
   const int xp_exports = 675;
   const int xp_imports = 422;
   const int xp_delay_imports = 8;
   const int xp_relocs = 9180;
   const int vista_delay_dlls = 4;
   const int vista_exports = 799;
   const int vista_imports = 476;
@@ skipping 29 matching lines @@
     {4, 4, 4, 4, win8_sections},
     {3, 3, 3, 13, win8_import_dlls},
     {w2k_delay_dlls, xp_delay_dlls, vista_delay_dlls, win7_delay_dlls,
      win8_delay_dlls},
     {w2k_exports, xp_exports, vista_exports, win7_exports, win8_exports},
     {w2k_imports, xp_imports, vista_imports, win7_imports, win8_imports},
     {w2k_delay_imports, xp_delay_imports,
      vista_delay_imports, win7_delay_imports, win8_delay_imports},
     {w2k_relocs, xp_relocs, vista_relocs, win7_relocs, win8_relocs}
   };
+  COMPILE_ASSERT(arraysize(expected[0]) == UNSUPPORTED_SET,
+                 expected_value_set_mismatch);
 
   if (value > relocs)
     return 0;
-  if (50 == os)
-    os = 0;  // 5.0
-  else if (51 == os || 52 == os)
-    os = 1;
-  else if (os == 60)
-    os = 2;  // 6.x
-  else if (os == 61)
-    os = 3;
-  else if (os >= 62)
-    os = 4;
-  else
-    return 0;
+  ExpectationSet expected_set = GetExpectationSet(os);
+  if (expected_set >= arraysize(expected)) {
+    // This should never happen.  Log a failure if it does.
+    EXPECT_NE(UNSUPPORTED_SET, expected_set);
+    expected_set = WIN_2K_SET;
+  }
 
-  return expected[value][os];
+  return expected[value][expected_set];
 }
 
 // Tests that we are able to enumerate stuff from a PE file, and that
 // the actual number of items found is within the expected range.
 TEST(PEImageTest, EnumeratesPE) {
-  // Windows Server 2003 is not supported as a test environment for this test.
-  if (base::win::GetVersion() == base::win::VERSION_SERVER_2003)
-    return;
   HMODULE module = LoadLibrary(L"advapi32.dll");
   ASSERT_TRUE(NULL != module);
 
   PEImage pe(module);
   int count = 0;
   EXPECT_TRUE(pe.VerifyMagic());
 
   DWORD os = pe.GetNTHeaders()->OptionalHeader.MajorOperatingSystemVersion;
   os = os * 10 + pe.GetNTHeaders()->OptionalHeader.MinorOperatingSystemVersion;
 
+  // Skip this test for unsupported OS versions.
+  if (GetExpectationSet(os) == UNSUPPORTED_SET)
+    return;
+
   pe.EnumSections(SectionsCallback, &count);
   EXPECT_EQ(GetExpectedValue(sections, os), count);
 
   count = 0;
   pe.EnumImportChunks(ImportChunksCallback, &count);
   EXPECT_EQ(GetExpectedValue(imports_dlls, os), count);
 
   count = 0;
   pe.EnumDelayImportChunks(DelayImportChunksCallback, &count);
   EXPECT_EQ(GetExpectedValue(delay_dlls, os), count);
@@ skipping 35 matching lines @@
   FARPROC address2 = pe.GetProcAddress(reinterpret_cast<char*>(ordinal));
   EXPECT_TRUE(address1 != NULL);
   EXPECT_TRUE(address2 != NULL);
   EXPECT_TRUE(address1 == address2);
 
   FreeLibrary(module);
 }
 
 }  // namespace win
 }  // namespace base