1  #include "pch.h"
  2  #include "TestHelpers.h"
  3  #include <os-detect.h>
  4  
  5  using namespace Microsoft::VisualStudio::CppUnitTestFramework;
  6  
  7  namespace UnitTestsCommonUtils
  8  {
  9      TEST_CLASS(OsDetectTests)
 10      {
 11      public:
 12          // IsAPIContractVxAvailable tests
 13          TEST_METHOD(IsAPIContractV8Available_ReturnsBoolean)
 14          {
 15              // This test verifies the function runs without crashing
 16              // The actual result depends on the OS version
 17              bool result = IsAPIContractV8Available();
 18              // Result is either true or false, both are valid
 19              Assert::IsTrue(result == true || result == false);
 20          }
 21  
 22          TEST_METHOD(IsAPIContractVxAvailable_V1_ReturnsTrue)
 23          {
 24              // API contract v1 should be available on any modern Windows
 25              bool result = IsAPIContractVxAvailable<1>();
 26              Assert::IsTrue(result);
 27          }
 28  
 29          TEST_METHOD(IsAPIContractVxAvailable_V5_ReturnsBooleanConsistently)
 30          {
 31              // Call multiple times to verify caching works correctly
 32              bool result1 = IsAPIContractVxAvailable<5>();
 33              bool result2 = IsAPIContractVxAvailable<5>();
 34              bool result3 = IsAPIContractVxAvailable<5>();
 35              Assert::AreEqual(result1, result2);
 36              Assert::AreEqual(result2, result3);
 37          }
 38  
 39          TEST_METHOD(IsAPIContractVxAvailable_V10_ReturnsBoolean)
 40          {
 41              bool result = IsAPIContractVxAvailable<10>();
 42              // Result depends on Windows version, but should not crash
 43              Assert::IsTrue(result == true || result == false);
 44          }
 45  
 46          TEST_METHOD(IsAPIContractVxAvailable_V15_ReturnsBoolean)
 47          {
 48              bool result = IsAPIContractVxAvailable<15>();
 49              // Higher API versions, may or may not be available
 50              Assert::IsTrue(result == true || result == false);
 51          }
 52  
 53          // Is19H1OrHigher tests
 54          TEST_METHOD(Is19H1OrHigher_ReturnsBoolean)
 55          {
 56              bool result = Is19H1OrHigher();
 57              // Result depends on OS version, but should not crash
 58              Assert::IsTrue(result == true || result == false);
 59          }
 60  
 61          TEST_METHOD(Is19H1OrHigher_ReturnsSameAsV8Contract)
 62          {
 63              // Is19H1OrHigher is implemented as IsAPIContractV8Available
 64              bool is19H1 = Is19H1OrHigher();
 65              bool isV8 = IsAPIContractV8Available();
 66              Assert::AreEqual(is19H1, isV8);
 67          }
 68  
 69          TEST_METHOD(Is19H1OrHigher_ConsistentAcrossMultipleCalls)
 70          {
 71              bool result1 = Is19H1OrHigher();
 72              bool result2 = Is19H1OrHigher();
 73              bool result3 = Is19H1OrHigher();
 74              Assert::AreEqual(result1, result2);
 75              Assert::AreEqual(result2, result3);
 76          }
 77  
 78          // Static caching behavior tests
 79          TEST_METHOD(StaticCaching_DifferentContractVersions_IndependentResults)
 80          {
 81              // Each template instantiation has its own static variable
 82              bool v1 = IsAPIContractVxAvailable<1>();
 83              (void)v1; // Suppress unused variable warning
 84  
 85              // v1 should be true on any modern Windows
 86              Assert::IsTrue(v1);
 87          }
 88  
 89          // Performance test (optional - verifies caching)
 90          TEST_METHOD(Performance_MultipleCallsAreFast)
 91          {
 92              // The static caching should make subsequent calls very fast
 93              auto start = std::chrono::high_resolution_clock::now();
 94  
 95              for (int i = 0; i < 10000; ++i)
 96              {
 97                  Is19H1OrHigher();
 98              }
 99  
100              auto end = std::chrono::high_resolution_clock::now();
101              auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
102  
103              // 10000 calls should complete in well under 1 second due to caching
104              Assert::IsTrue(duration.count() < 1000);
105          }
106      };
107  }