text: /*
   * Copyright (C) 2018-2020 Intel Corporation
   *
   * SPDX-License-Identifier: MIT
   *
   */
  
  #include "shared/source/command_stream/command_stream_receiver.h"
  #include "shared/source/command_stream/linear_stream.h"
  #include "shared/source/command_stream/preemption.h"
  #include "shared/source/command_stream/scratch_space_controller.h"
  #include "shared/source/gmm_helper/page_table_mngr.h"
  #include "shared/source/helpers/cache_policy.h"
  #include "shared/source/helpers/hw_helper.h"
  #include "shared/source/helpers/timestamp_packet.h"
  #include "shared/source/memory_manager/graphics_allocation.h"
  #include "shared/source/memory_manager/internal_allocation_storage.h"
  #include "shared/source/memory_manager/memory_manager.h"
  #include "shared/source/memory_manager/surface.h"
  #include "shared/source/utilities/tag_allocator.h"
  #include "shared/test/unit_test/helpers/debug_manager_state_restore.h"
  
  #include "opencl/source/mem_obj/buffer.h"
  #include "opencl/source/platform/platform.h"
  #include "opencl/test/unit_test/fixtures/device_fixture.h"
  #include "opencl/test/unit_test/fixtures/multi_root_device_fixture.h"
  #include "opencl/test/unit_test/gen_common/matchers.h"
  #include "opencl/test/unit_test/helpers/raii_hw_helper.h"
  #include "opencl/test/unit_test/helpers/unit_test_helper.h"
  #include "opencl/test/unit_test/mocks/mock_buffer.h"
  #include "opencl/test/unit_test/mocks/mock_builtins.h"
  #include "opencl/test/unit_test/mocks/mock_context.h"
  #include "opencl/test/unit_test/mocks/mock_csr.h"
  #include "opencl/test/unit_test/mocks/mock_execution_environment.h"
  #include "opencl/test/unit_test/mocks/mock_graphics_allocation.h"
  #include "opencl/test/unit_test/mocks/mock_hw_helper.h"
  #include "opencl/test/unit_test/mocks/mock_memory_manager.h"
  #include "opencl/test/unit_test/mocks/mock_program.h"
  #include "test.h"
  
  #include "command_stream_receiver_simulated_hw.h"
  #include "gmock/gmock.h"
  
  using namespace NEO;
  
  struct CommandStreamReceiverTest : public DeviceFixture,
                                     public ::testing::Test {
      void SetUp() override {
          DeviceFixture::SetUp();
  
          commandStreamReceiver = &pDevice->getGpgpuCommandStreamReceiver();
          ASSERT_NE(nullptr, commandStreamReceiver);
          memoryManager = commandStreamReceiver->getMemoryManager();
          internalAllocationStorage = commandStreamReceiver->getInternalAllocationStorage();
      }
  
      void TearDown() override {
          DeviceFixture::TearDown();
      }
  
      CommandStreamReceiver *commandStreamReceiver;
      MemoryManager *memoryManager;
      InternalAllocationStorage *internalAllocationStorage;
  };
  
  HWTEST_F(CommandStreamReceiverTest, WhenCreatingCsrThenDefaultValuesAreSet) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      EXPECT_EQ(0u, csr.peekTaskLevel());
      EXPECT_EQ(0u, csr.peekTaskCount());
      EXPECT_FALSE(csr.isPreambleSent);
  }
  
  HWTEST_F(CommandStreamReceiverTest, WhenCreatingCsrThenFlagsAreSetCorrectly) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      csr.initProgrammingFlags();
      EXPECT_FALSE(csr.isPreambleSent);
      EXPECT_FALSE(csr.GSBAFor32BitProgrammed);
      EXPECT_TRUE(csr.mediaVfeStateDirty);
      EXPECT_FALSE(csr.lastVmeSubslicesConfig);
      EXPECT_EQ(0u, csr.lastSentL3Config);
      EXPECT_EQ(-1, csr.lastSentCoherencyRequest);
      EXPECT_EQ(-1, csr.lastMediaSamplerConfig);
      EXPECT_EQ(PreemptionMode::Initial, csr.lastPreemptionMode);
      EXPECT_EQ(0u, csr.latestSentStatelessMocsConfig);
  }
  
  TEST_F(CommandStreamReceiverTest, WhenMakingResidentThenBufferResidencyFlagIsSet) {
      MockContext context;
      float srcMemory[] = {1.0f};
  
      auto retVal = CL_INVALID_VALUE;
      auto buffer = Buffer::create(
          &context,
          CL_MEM_USE_HOST_PTR,
          sizeof(srcMemory),
          srcMemory,
          retVal);
      ASSERT_NE(nullptr, buffer);
      EXPECT_FALSE(buffer->getGraphicsAllocation()->isResident(commandStreamReceiver->getOsContext().getContextId()));
  
      commandStreamReceiver->makeResident(*buffer->getGraphicsAllocation());
  
      EXPECT_TRUE(buffer->getGraphicsAllocation()->isResident(commandStreamReceiver->getOsContext().getContextId()));
  
      delete buffer;
  }
  
  TEST_F(CommandStreamReceiverTest, givenBaseDownloadAllocationCalledThenDoesNotChangeAnything) {
      auto *memoryManager = commandStreamReceiver->getMemoryManager();
  
      GraphicsAllocation *graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
  
      ASSERT_NE(nullptr, graphicsAllocation);
      auto numEvictionAllocsBefore = commandStreamReceiver->getEvictionAllocations().size();
      commandStreamReceiver->CommandStreamReceiver::downloadAllocation(*graphicsAllocation);
      auto numEvictionAllocsAfter = commandStreamReceiver->getEvictionAllocations().size();
      EXPECT_EQ(numEvictionAllocsBefore, numEvictionAllocsAfter);
  
      memoryManager->freeGraphicsMemory(graphicsAllocation);
  }
  
  TEST_F(CommandStreamReceiverTest, WhenCommandStreamReceiverIsCreatedThenItHasATagValue) {
      EXPECT_NE(nullptr, const_cast<uint32_t *>(commandStreamReceiver->getTagAddress()));
  }
  
  TEST_F(CommandStreamReceiverTest, WhenGettingCommandStreamerThenValidPointerIsReturned) {
      auto &cs = commandStreamReceiver->getCS();
      EXPECT_NE(nullptr, &cs);
  }
  
  TEST_F(CommandStreamReceiverTest, WhenCommandStreamReceiverIsCreatedThenAvailableMemoryIsGreaterOrEqualRequiredSize) {
      size_t requiredSize = 16384;
      const auto &commandStream = commandStreamReceiver->getCS(requiredSize);
      ASSERT_NE(nullptr, &commandStream);
      EXPECT_GE(commandStream.getAvailableSpace(), requiredSize);
  }
  
  TEST_F(CommandStreamReceiverTest, WhenCommandStreamReceiverIsCreatedThenCsOverfetchSizeIsIncludedInGraphicsAllocation) {
      size_t sizeRequested = 560;
      const auto &commandStream = commandStreamReceiver->getCS(sizeRequested);
      ASSERT_NE(nullptr, &commandStream);
      auto *allocation = commandStream.getGraphicsAllocation();
      ASSERT_NE(nullptr, allocation);
  
      size_t expectedTotalSize = alignUp(sizeRequested + MemoryConstants::cacheLineSize + CSRequirements::csOverfetchSize, MemoryConstants::pageSize64k);
  
      EXPECT_LT(commandStream.getAvailableSpace(), expectedTotalSize);
      EXPECT_LE(commandStream.getAvailableSpace(), expectedTotalSize - CSRequirements::csOverfetchSize);
      EXPECT_EQ(expectedTotalSize, allocation->getUnderlyingBufferSize());
  }
  
  TEST_F(CommandStreamReceiverTest, WhenRequestingAdditionalSpaceThenCsrGetsAdditionalSpace) {
      auto &commandStreamInitial = commandStreamReceiver->getCS();
      size_t requiredSize = commandStreamInitial.getMaxAvailableSpace() + 42;
  
      const auto &commandStream = commandStreamReceiver->getCS(requiredSize);
      ASSERT_NE(nullptr, &commandStream);
      EXPECT_GE(commandStream.getMaxAvailableSpace(), requiredSize);
  }
  
  TEST_F(CommandStreamReceiverTest, givenCommandStreamReceiverWhenGetCSIsCalledThenCommandStreamAllocationTypeShouldBeSetToLinearStream) {
      const auto &commandStream = commandStreamReceiver->getCS();
      auto commandStreamAllocation = commandStream.getGraphicsAllocation();
      ASSERT_NE(nullptr, commandStreamAllocation);
  
      EXPECT_EQ(GraphicsAllocation::AllocationType::COMMAND_BUFFER, commandStreamAllocation->getAllocationType());
  }
  
  HWTEST_F(CommandStreamReceiverTest, whenStoreAllocationThenStoredAllocationHasTaskCountFromCsr) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      auto *memoryManager = csr.getMemoryManager();
      auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
  
      EXPECT_FALSE(allocation->isUsed());
  
      csr.taskCount = 2u;
  
      csr.getInternalAllocationStorage()->storeAllocation(std::unique_ptr<GraphicsAllocation>(allocation), REUSABLE_ALLOCATION);
  
      EXPECT_EQ(csr.peekTaskCount(), allocation->getTaskCount(csr.getOsContext().getContextId()));
  }
  
  HWTEST_F(CommandStreamReceiverTest, givenCommandStreamReceiverWhenCheckedForInitialStatusOfStatelessMocsIndexThenUnknownMocsIsReturend) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      EXPECT_EQ(CacheSettings::unknownMocs, csr.latestSentStatelessMocsConfig);
  }
  
  TEST_F(CommandStreamReceiverTest, WhenMakingResidentThenAllocationIsPushedToMemoryManagerResidencyList) {
      auto *memoryManager = commandStreamReceiver->getMemoryManager();
  
      GraphicsAllocation *graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
  
      ASSERT_NE(nullptr, graphicsAllocation);
  
      commandStreamReceiver->makeResident(*graphicsAllocation);
  
      auto &residencyAllocations = commandStreamReceiver->getResidencyAllocations();
  
      ASSERT_EQ(1u, residencyAllocations.size());
      EXPECT_EQ(graphicsAllocation, residencyAllocations[0]);
  
      memoryManager->freeGraphicsMemory(graphicsAllocation);
  }
  
  TEST_F(CommandStreamReceiverTest, GivenNoParamatersWhenMakingResidentThenResidencyDoesNotOccur) {
      commandStreamReceiver->processResidency(commandStreamReceiver->getResidencyAllocations(), 0u);
      auto &residencyAllocations = commandStreamReceiver->getResidencyAllocations();
      EXPECT_EQ(0u, residencyAllocations.size());
  }
  
  TEST_F(CommandStreamReceiverTest, givenForced32BitAddressingWhenDebugSurfaceIsAllocatedThenRegularAllocationIsReturned) {
      auto *memoryManager = commandStreamReceiver->getMemoryManager();
      memoryManager->setForce32BitAllocations(true);
      auto allocation = commandStreamReceiver->allocateDebugSurface(1024);
      EXPECT_FALSE(allocation->is32BitAllocation());
  }
  
  HWTEST_F(CommandStreamReceiverTest, givenDefaultCommandStreamReceiverThenDefaultDispatchingPolicyIsImmediateSubmission) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      EXPECT_EQ(DispatchMode::ImmediateDispatch, csr.dispatchMode);
  }
  
  HWTEST_F(CommandStreamReceiverTest, givenCsrWhenGetIndirectHeapIsCalledThenHeapIsReturned) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      auto &heap = csr.getIndirectHeap(IndirectHeap::DYNAMIC_STATE, 10u);
      EXPECT_NE(nullptr, heap.getGraphicsAllocation());
      EXPECT_NE(nullptr, csr.indirectHeap[IndirectHeap::DYNAMIC_STATE]);
      EXPECT_EQ(&heap, csr.indirectHeap[IndirectHeap::DYNAMIC_STATE]);
  }
  
  HWTEST_F(CommandStreamReceiverTest, givenCsrWhenReleaseIndirectHeapIsCalledThenHeapAllocationIsNull) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      auto &heap = csr.getIndirectHeap(IndirectHeap::DYNAMIC_STATE, 10u);
      csr.releaseIndirectHeap(IndirectHeap::DYNAMIC_STATE);
      EXPECT_EQ(nullptr, heap.getGraphicsAllocation());
      EXPECT_EQ(0u, heap.getMaxAvailableSpace());
  }
  
  HWTEST_F(CommandStreamReceiverTest, givenCsrWhenAllocateHeapMemoryIsCalledThenHeapMemoryIsAllocated) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      IndirectHeap *dsh = nullptr;
      csr.allocateHeapMemory(IndirectHeap::DYNAMIC_STATE, 4096u, dsh);
      EXPECT_NE(nullptr, dsh);
      ASSERT_NE(nullptr, dsh->getGraphicsAllocation());
      csr.getMemoryManager()->freeGraphicsMemory(dsh->getGraphicsAllocation());
      delete dsh;
  }
  
  TEST(CommandStreamReceiverSimpleTest, givenCsrWithoutTagAllocationWhenGetTagAllocationIsCalledThenNullptrIsReturned) {
      MockExecutionEnvironment executionEnvironment;
      executionEnvironment.prepareRootDeviceEnvironments(1);
      executionEnvironment.initializeMemoryManager();
      MockCommandStreamReceiver csr(executionEnvironment, 0);
      EXPECT_EQ(nullptr, csr.getTagAllocation());
  }
  
  TEST(CommandStreamReceiverSimpleTest, givenCsrWhenSubmitiingBatchBufferThenTaskCountIsIncrementedAndLatestsValuesSetCorrectly) {
      MockExecutionEnvironment executionEnvironment;
      executionEnvironment.prepareRootDeviceEnvironments(1);
      executionEnvironment.initializeMemoryManager();
      MockCommandStreamReceiver csr(executionEnvironment, 0);
  
      GraphicsAllocation *commandBuffer = executionEnvironment.memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
      ASSERT_NE(nullptr, commandBuffer);
      LinearStream cs(commandBuffer);
  
      BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, QueueSliceCount::defaultSliceCount, cs.getUsed(), &cs, nullptr};
      ResidencyContainer residencyList;
  
      auto expectedTaskCount = csr.peekTaskCount() + 1;
      csr.submitBatchBuffer(batchBuffer, residencyList);
  
      EXPECT_EQ(expectedTaskCount, csr.peekTaskCount());
      EXPECT_EQ(expectedTaskCount, csr.peekLatestFlushedTaskCount());
      EXPECT_EQ(expectedTaskCount, csr.peekLatestSentTaskCount());
  
      executionEnvironment.memoryManager->freeGraphicsMemoryImpl(commandBuffer);
  }
  
  HWTEST_F(CommandStreamReceiverTest, givenDebugVariableEnabledWhenCreatingCsrThenEnableTimestampPacketWriteMode) {
      DebugManagerStateRestore restore;
  
      DebugManager.flags.EnableTimestampPacket.set(true);
      CommandStreamReceiverHw<FamilyType> csr1(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex());
      EXPECT_TRUE(csr1.peekTimestampPacketWriteEnabled());
  
      DebugManager.flags.EnableTimestampPacket.set(false);
      CommandStreamReceiverHw<FamilyType> csr2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex());
      EXPECT_FALSE(csr2.peekTimestampPacketWriteEnabled());
  }
  
  HWTEST_F(CommandStreamReceiverTest, whenCsrIsCreatedThenUseTimestampPacketWriteIfPossible) {
      CommandStreamReceiverHw<FamilyType> csr(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex());
      EXPECT_EQ(UnitTestHelper<FamilyType>::isTimestampPacketWriteSupported(), csr.peekTimestampPacketWriteEnabled());
  }
  
  TEST_F(CommandStreamReceiverTest, whenGetEventTsAllocatorIsCalledItReturnsSameTagAllocator) {
      TagAllocator<HwTimeStamps> *allocator = commandStreamReceiver->getEventTsAllocator();
      EXPECT_NE(nullptr, allocator);
      TagAllocator<HwTimeStamps> *allocator2 = commandStreamReceiver->getEventTsAllocator();
      EXPECT_EQ(allocator2, allocator);
  }
  
  TEST_F(CommandStreamReceiverTest, whenGetEventPerfCountAllocatorIsCalledItReturnsSameTagAllocator) {
      const uint32_t gpuReportSize = 100;
      TagAllocator<HwPerfCounter> *allocator = commandStreamReceiver->getEventPerfCountAllocator(gpuReportSize);
      EXPECT_NE(nullptr, allocator);
      TagAllocator<HwPerfCounter> *allocator2 = commandStreamReceiver->getEventPerfCountAllocator(gpuReportSize);
      EXPECT_EQ(allocator2, allocator);
  }
  
  HWTEST_F(CommandStreamReceiverTest, givenTimestampPacketAllocatorWhenAskingForTagThenReturnValidObject) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      EXPECT_EQ(nullptr, csr.timestampPacketAllocator.get());
  
      TagAllocator<TimestampPacketStorage> *allocator = csr.getTimestampPacketAllocator();
      EXPECT_NE(nullptr, csr.timestampPacketAllocator.get());
      EXPECT_EQ(allocator, csr.timestampPacketAllocator.get());
  
      TagAllocator<TimestampPacketStorage> *allocator2 = csr.getTimestampPacketAllocator();
      EXPECT_EQ(allocator, allocator2);
  
      auto node1 = allocator->getTag();
      auto node2 = allocator->getTag();
      EXPECT_NE(nullptr, node1);
      EXPECT_NE(nullptr, node2);
      EXPECT_NE(node1, node2);
  }
  
  HWTEST_F(CommandStreamReceiverTest, givenUltCommandStreamReceiverWhenAddAubCommentIsCalledThenCallAddAubCommentOnCsr) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      csr.addAubComment("message");
      EXPECT_TRUE(csr.addAubCommentCalled);
  }
  
  TEST(CommandStreamReceiverSimpleTest, givenCsrWhenDownloadAllocationCalledVerifyCallOccurs) {
      MockExecutionEnvironment executionEnvironment;
      executionEnvironment.prepareRootDeviceEnvironments(1);
      executionEnvironment.initializeMemoryManager();
      MockCommandStreamReceiver csr(executionEnvironment, 0);
      MockGraphicsAllocation graphicsAllocation;
  
      csr.downloadAllocation(graphicsAllocation);
      EXPECT_TRUE(csr.downloadAllocationCalled);
  }
  
  HWTEST_F(CommandStreamReceiverTest, givenUltCommandStreamReceiverWhenDownloadAllocationIsCalledThenVerifyCallOccurs) {
      auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
      auto *memoryManager = commandStreamReceiver->getMemoryManager();
  
      GraphicsAllocation *graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
  
      ASSERT_NE(nullptr, graphicsAllocation);
      csr.downloadAllocation(*graphicsAllocation);
      EXPECT_TRUE(csr.downloadAllocationCalled);
      memoryManager->freeGraphicsMemory(graphicsAllocation);
  }
  
  TEST(CommandStreamReceiverSimpleTest, givenCommandStreamReceiverWhenItIsDestroyedThenItDestroysTagAllocation) {
      struct MockGraphicsAllocationWithDestructorTracing : public MockGraphicsAllocation {
          using MockGraphicsAllocation::MockGraphicsAllocation;
          ~MockGraphicsAllocationWithDestructorTracing() override { *destructorCalled = true; }
          bool *destructorCalled = nullptr;
      };
  
      bool destructorCalled = false;
  
      auto mockGraphicsAllocation = new MockGraphicsAllocationWithDestructorTracing(0, GraphicsAllocation::AllocationType::UNKNOWN, nullptr, 0llu, 0llu, 1u, MemoryPool::MemoryNull);
      mockGraphicsAllocation->destructorCalled = &destructorCalled;
      MockExecutionEnvironment executionEnvironment(*platformDevices);
      auto csr = std::make_unique<MockCommandStreamReceiver>(executionEnvironment, 0);
      executionEnvironment.memoryManager.reset(new OsAgnosticMemoryManager(executionEnvironment));
      csr->setTagAllocation(mockGraphicsAllocation);
      EXPECT_FALSE(destructorCalled);
      csr.reset(nullptr);
      EXPECT_TRUE(destructorCalled);
  }
  
  TEST(CommandStreamReceiverSimpleTest, givenCommandStreamReceiverWhenInitializeTagAllocationIsCalledThenTagAllocationIsBeingAllocated) {
      MockExecutionEnvironment executionEnvironment(*platformDevices);
      auto csr = std::make_unique<MockCommandStreamReceiver>(executionEnvironment, 0);
      executionEnvironment.memoryManager.reset(new OsAgnosticMemoryManager(executionEnvironment));
      EXPECT_EQ(nullptr, csr->getTagAllocation());
      EXPECT_TRUE(csr->getTagAddress() == nullptr);
      csr->initializeTagAllocation();
      EXPECT_NE(nullptr, csr->getTagAllocation());
      EXPECT_EQ(GraphicsAllocation::AllocationType::TAG_BUFFER, csr->getTagAllocation()->getAllocationType());
      EXPECT_TRUE(csr->getTagAddress() != nullptr);
      EXPECT_EQ(*csr->getTagAddress(), initialHardwareTag);
  }
  
  HWTEST_F(CommandStreamReceiverTest, givenCommandStreamReceiverWhenFenceAllocationIsRequiredAndCreateGlobalFenceAllocationIsCalledThenFenceAllocationIsAllocated) {
      RAIIHwHelperFactory<MockHwHelperWithFenceAllocation<FamilyType>> hwHelperBackup{pDevice->getHardwareInfo().platform.eRenderCoreFamily};
  
      MockCsrHw<FamilyType> csr(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex());
      EXPECT_EQ(nullptr, csr.globalFenceAllocation);
  
      EXPECT_TRUE(csr.createGlobalFenceAllocation());
  
      ASSERT_NE(nullptr, csr.globalFenceAllocation);
      EXPECT_EQ(GraphicsAllocation::AllocationType::GLOBAL_FENCE, csr.globalFenceAllocation->getAllocationType());
  }
  
  TEST(CommandStreamReceiverSimpleTest, givenNullHardwareDebugModeWhenInitializeTagAllocationIsCalledThenTagAllocationIsBeingAllocatedAndinitialValueIsMinusOne) {
      DebugManagerStateRestore dbgRestore;
      DebugManager.flags.EnableNullHardware.set(true);
      MockExecutionEnvironment executionEnvironment(*platformDevices);
      auto csr = std::make_unique<MockCommandStreamReceiver>(executionEnvironment, 0);
      executionEnvironment.memoryManager.reset(new OsAgnosticMemoryManager(executionEnvironment));
      EXPECT_EQ(nullptr, csr->getTagAllocation());
      EXPECT_TRUE(csr->getTagAddress() == nullptr);
      csr->initializeTagAllocation();
      EXPECT_NE(nullptr, csr->getTagAllocation());
      EXPECT_TRUE(csr->getTagAddress() != nullptr);
      EXPECT_EQ(*csr->getTagAddress(), static_cast<uint32_t>(-1));
  }
  
  TEST(CommandStreamReceiverSimpleTest, givenVariousDataSetsWhenVerifyingMemoryThenCorrectValueIsReturned) {
      MockExecutionEnvironment executionEnvironment;
      executionEnvironment.prepareRootDeviceEnvironments(1);
      executionEnvironment.initializeMemoryManager();
      MockCommandStreamReceiver csr(executionEnvironment, 0);
  
      constexpr size_t setSize = 6;
      uint8_t setA1[setSize] = {4, 3, 2, 1, 2, 10};
      uint8_t setA2[setSize] = {4, 3, 2, 1, 2, 10};
      uint8_t setB1[setSize] = {40, 15, 3, 11, 17, 4};
      uint8_t setB2[setSize] = {40, 15, 3, 11, 17, 4};
  
      constexpr auto compareEqual = AubMemDump::CmdServicesMemTraceMemoryCompare::CompareOperationValues::CompareEqual;
      constexpr auto compareNotEqual = AubMemDump::CmdServicesMemTraceMemoryCompare::CompareOperationValues::CompareNotEqual;
  
      EXPECT_EQ(CL_SUCCESS, csr.expectMemory(setA1, setA2, setSize, compareEqual));
      EXPECT_EQ(CL_SUCCESS, csr.expectMemory(setB1, setB2, setSize, compareEqual));
      EXPECT_EQ(CL_INVALID_VALUE, csr.expectMemory(setA1, setA2, setSize, compareNotEqual));
      EXPECT_EQ(CL_INVALID_VALUE, csr.expectMemory(setB1, setB2, setSize, compareNotEqual));
  
      EXPECT_EQ(CL_INVALID_VALUE, csr.expectMemory(setA1, setB1, setSize, compareEqual));
      EXPECT_EQ(CL_INVALID_VALUE, csr.expectMemory(setA2, setB2, setSize, compareEqual));
      EXPECT_EQ(CL_SUCCESS, csr.expectMemory(setA1, setB1, setSize, compareNotEqual));
      EXPECT_EQ(CL_SUCCESS, csr.expectMemory(setA2, setB2, setSize, compareNotEqual));
  }
  
  TEST(CommandStreamReceiverMultiContextTests, givenMultipleCsrsWhenSameResourcesAreUsedThenResidencyIsProperlyHandled) {
      auto executionEnvironment = platform()->peekExecutionEnvironment();
  
      std::unique_ptr<MockDevice> device(Device::create<MockDevice>(executionEnvironment, 0u));
  
      auto &commandStreamReceiver0 = *device->commandStreamReceivers[0];
      auto &commandStreamReceiver1 = *device->commandStreamReceivers[1];
  
      auto csr0ContextId = commandStreamReceiver0.getOsContext().getContextId();
      auto csr1ContextId = commandStreamReceiver1.getOsContext().getContextId();
  
      MockGraphicsAllocation graphicsAllocation;
  
      commandStreamReceiver0.makeResident(graphicsAllocation);
      EXPECT_EQ(1u, commandStreamReceiver0.getResidencyAllocations().size());
      EXPECT_EQ(0u, commandStreamReceiver1.getResidencyAllocations().size());
  
      commandStreamReceiver1.makeResident(graphicsAllocation);
      EXPECT_EQ(1u, commandStreamReceiver0.getResidencyAllocations().size());
      EXPECT_EQ(1u, commandStreamReceiver1.getResidencyAllocations().size());
  
      EXPECT_EQ(1u, graphicsAllocation.getResidencyTaskCount(csr0ContextId));
      EXPECT_EQ(1u, graphicsAllocation.getResidencyTaskCount(csr1ContextId));
  
      commandStreamReceiver0.makeNonResident(graphicsAllocation);
      EXPECT_FALSE(graphicsAllocation.isResident(csr0ContextId));
      EXPECT_TRUE(graphicsAllocation.isResident(csr1ContextId));
  
      commandStreamReceiver1.makeNonResident(graphicsAllocation);
      EXPECT_FALSE(graphicsAllocation.isResident(csr0ContextId));
      EXPECT_FALSE(graphicsAllocation.isResident(csr1ContextId));
  
      EXPECT_EQ(1u, commandStreamReceiver0.getEvictionAllocations().size());
      EXPECT_EQ(1u, commandStreamReceiver1.getEvictionAllocations().size());
  }
  
  struct CreateAllocationForHostSurfaceTest : public ::testing::Test {
      void SetUp() override {
          executionEnvironment = platform()->peekExecutionEnvironment();
          executionEnvironment->setHwInfo(&hwInfo);
          gmockMemoryManager = new ::testing::NiceMock<GMockMemoryManager>(*executionEnvironment);
          executionEnvironment->memoryManager.reset(gmockMemoryManager);
          device.reset(MockDevice::create<MockDevice>(executionEnvironment, 0u));
          commandStreamReceiver = &device->getGpgpuCommandStreamReceiver();
      }
      HardwareInfo hwInfo = *platformDevices[0];
      ExecutionEnvironment *executionEnvironment = nullptr;
      GMockMemoryManager *gmockMemoryManager = nullptr;
      std::unique_ptr<MockDevice> device;
      CommandStreamReceiver *commandStreamReceiver = nullptr;
  };
  
  TEST_F(CreateAllocationForHostSurfaceTest, givenReadOnlyHostPointerWhenAllocationForHostSurfaceWithPtrCopyAllowedIsCreatedThenCopyAllocationIsCreatedAndMemoryCopied) {
      const char memory[8] = {1, 2, 3, 4, 5, 6, 7, 8};
      size_t size = sizeof(memory);
      HostPtrSurface surface(const_cast<char *>(memory), size, true);
  
      if (!gmockMemoryManager->useNonSvmHostPtrAlloc(GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR, device->getRootDeviceIndex())) {
          EXPECT_CALL(*gmockMemoryManager, populateOsHandles(::testing::_, device->getRootDeviceIndex()))
              .Times(1)
              .WillOnce(::testing::Return(MemoryManager::AllocationStatus::InvalidHostPointer));
      } else {
          EXPECT_CALL(*gmockMemoryManager, allocateGraphicsMemoryForNonSvmHostPtr(::testing::_))
              .Times(1)
              .WillOnce(::testing::Return(nullptr));
      }
  
      bool result = commandStreamReceiver->createAllocationForHostSurface(surface, false);
      EXPECT_TRUE(result);
  
      auto allocation = surface.getAllocation();
      ASSERT_NE(nullptr, allocation);
  
      EXPECT_NE(memory, allocation->getUnderlyingBuffer());
      EXPECT_THAT(allocation->getUnderlyingBuffer(), MemCompare(memory, size));
  
      allocation->updateTaskCount(commandStreamReceiver->peekLatestFlushedTaskCount(), commandStreamReceiver->getOsContext().getContextId());
  }
  
  TEST_F(CreateAllocationForHostSurfaceTest, givenReadOnlyHostPointerWhenAllocationForHostSurfaceWithPtrCopyNotAllowedIsCreatedThenCopyAllocationIsNotCreated) {
      const char memory[8] = {1, 2, 3, 4, 5, 6, 7, 8};
      size_t size = sizeof(memory);
      HostPtrSurface surface(const_cast<char *>(memory), size, false);
  
      if (!gmockMemoryManager->useNonSvmHostPtrAlloc(GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR, device->getRootDeviceIndex())) {
          EXPECT_CALL(*gmockMemoryManager, populateOsHandles(::testing::_, device->getRootDeviceIndex()))
              .Times(1)
              .WillOnce(::testing::Return(MemoryManager::AllocationStatus::InvalidHostPointer));
      } else {
          EXPECT_CALL(*gmockMemoryManager, allocateGraphicsMemoryForNonSvmHostPtr(::testing::_))
              .Times(1)
              .WillOnce(::testing::Return(nullptr));
      }
  
      bool result = commandStreamReceiver->createAllocationForHostSurface(surface, false);
      EXPECT_FALSE(result);
  
      auto allocation = surface.getAllocation();
      EXPECT_EQ(nullptr, allocation);
  }
  
  struct ReducedAddrSpaceCommandStreamReceiverTest : public CreateAllocationForHostSurfaceTest {
      void SetUp() override {
          hwInfo.capabilityTable.gpuAddressSpace = MemoryConstants::max32BitAddress;
          CreateAllocationForHostSurfaceTest::SetUp();
      }
  };
  
  TEST_F(ReducedAddrSpaceCommandStreamReceiverTest,
         givenReducedGpuAddressSpaceWhenAllocationForHostSurfaceIsCreatedThenAllocateGraphicsMemoryForNonSvmHostPtrIsCalled) {
      if (is32bit) {
          GTEST_SKIP();
      }
  
      char memory[8] = {};
      HostPtrSurface surface(memory, sizeof(memory), false);
  
      EXPECT_CALL(*gmockMemoryManager, allocateGraphicsMemoryForNonSvmHostPtr(::testing::_))
          .Times(1)
          .WillOnce(::testing::Return(nullptr));
  
      bool result = commandStreamReceiver->createAllocationForHostSurface(surface, false);
      EXPECT_FALSE(result);
  }
  
  TEST_F(CommandStreamReceiverTest, givenMinimumSizeDoesNotExceedCurrentWhenCallingEnsureCommandBufferAllocationThenDoNotReallocate) {
      GraphicsAllocation *allocation = memoryManager->allocateGraphicsMemoryWithProperties({commandStreamReceiver->getRootDeviceIndex(), 128u, GraphicsAllocation::AllocationType::COMMAND_BUFFER});
      LinearStream commandStream{allocation};
  
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 100u, 0u);
      EXPECT_EQ(allocation, commandStream.getGraphicsAllocation());
      EXPECT_EQ(128u, commandStream.getMaxAvailableSpace());
  
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 128u, 0u);
      EXPECT_EQ(allocation, commandStream.getGraphicsAllocation());
      EXPECT_EQ(128u, commandStream.getMaxAvailableSpace());
  
      memoryManager->freeGraphicsMemory(commandStream.getGraphicsAllocation());
  }
  
  TEST_F(CommandStreamReceiverTest, givenMinimumSizeExceedsCurrentWhenCallingEnsureCommandBufferAllocationThenReallocate) {
      GraphicsAllocation *allocation = memoryManager->allocateGraphicsMemoryWithProperties({commandStreamReceiver->getRootDeviceIndex(), 128u, GraphicsAllocation::AllocationType::COMMAND_BUFFER});
      LinearStream commandStream{allocation};
  
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 129u, 0u);
      EXPECT_NE(allocation, commandStream.getGraphicsAllocation());
      memoryManager->freeGraphicsMemory(commandStream.getGraphicsAllocation());
  }
  
  TEST_F(CommandStreamReceiverTest, givenMinimumSizeExceedsCurrentWhenCallingEnsureCommandBufferAllocationThenReallocateAndAlignSizeTo64kb) {
      GraphicsAllocation *allocation = memoryManager->allocateGraphicsMemoryWithProperties({commandStreamReceiver->getRootDeviceIndex(), 128u, GraphicsAllocation::AllocationType::COMMAND_BUFFER});
      LinearStream commandStream{allocation};
  
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 129u, 0u);
      EXPECT_EQ(MemoryConstants::pageSize64k, commandStream.getGraphicsAllocation()->getUnderlyingBufferSize());
      EXPECT_EQ(MemoryConstants::pageSize64k, commandStream.getMaxAvailableSpace());
  
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, MemoryConstants::pageSize64k + 1u, 0u);
      EXPECT_EQ(2 * MemoryConstants::pageSize64k, commandStream.getGraphicsAllocation()->getUnderlyingBufferSize());
      EXPECT_EQ(2 * MemoryConstants::pageSize64k, commandStream.getMaxAvailableSpace());
  
      memoryManager->freeGraphicsMemory(commandStream.getGraphicsAllocation());
  }
  
  TEST_F(CommandStreamReceiverTest, givenAdditionalAllocationSizeWhenCallingEnsureCommandBufferAllocationThenSizesOfAllocationAndCommandBufferAreCorrect) {
      GraphicsAllocation *allocation = memoryManager->allocateGraphicsMemoryWithProperties({commandStreamReceiver->getRootDeviceIndex(), 128u, GraphicsAllocation::AllocationType::COMMAND_BUFFER});
      LinearStream commandStream{allocation};
  
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 129u, 350u);
      EXPECT_NE(allocation, commandStream.getGraphicsAllocation());
      EXPECT_EQ(MemoryConstants::pageSize64k, commandStream.getGraphicsAllocation()->getUnderlyingBufferSize());
      EXPECT_EQ(MemoryConstants::pageSize64k - 350u, commandStream.getMaxAvailableSpace());
  
      memoryManager->freeGraphicsMemory(commandStream.getGraphicsAllocation());
  }
  
  TEST_F(CommandStreamReceiverTest, givenMinimumSizeExceedsCurrentAndNoAllocationsForReuseWhenCallingEnsureCommandBufferAllocationThenAllocateMemoryFromMemoryManager) {
      LinearStream commandStream;
  
      EXPECT_TRUE(internalAllocationStorage->getAllocationsForReuse().peekIsEmpty());
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 1u, 0u);
      EXPECT_NE(nullptr, commandStream.getGraphicsAllocation());
  
      memoryManager->freeGraphicsMemory(commandStream.getGraphicsAllocation());
  }
  
  TEST_F(CommandStreamReceiverTest, givenMinimumSizeExceedsCurrentAndAllocationsForReuseWhenCallingEnsureCommandBufferAllocationThenObtainAllocationFromInternalAllocationStorage) {
      auto allocation = memoryManager->allocateGraphicsMemoryWithProperties({commandStreamReceiver->getRootDeviceIndex(), MemoryConstants::pageSize64k, GraphicsAllocation::AllocationType::COMMAND_BUFFER});
      internalAllocationStorage->storeAllocation(std::unique_ptr<GraphicsAllocation>{allocation}, REUSABLE_ALLOCATION);
      LinearStream commandStream;
  
      EXPECT_FALSE(internalAllocationStorage->getAllocationsForReuse().peekIsEmpty());
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 1u, 0u);
      EXPECT_EQ(allocation, commandStream.getGraphicsAllocation());
      EXPECT_TRUE(internalAllocationStorage->getAllocationsForReuse().peekIsEmpty());
  
      memoryManager->freeGraphicsMemory(commandStream.getGraphicsAllocation());
  }
  
  TEST_F(CommandStreamReceiverTest, givenMinimumSizeExceedsCurrentAndNoSuitableReusableAllocationWhenCallingEnsureCommandBufferAllocationThenObtainAllocationMemoryManager) {
      auto allocation = memoryManager->allocateGraphicsMemoryWithProperties({commandStreamReceiver->getRootDeviceIndex(), MemoryConstants::pageSize64k, GraphicsAllocation::AllocationType::COMMAND_BUFFER});
      internalAllocationStorage->storeAllocation(std::unique_ptr<GraphicsAllocation>{allocation}, REUSABLE_ALLOCATION);
      LinearStream commandStream;
  
      EXPECT_FALSE(internalAllocationStorage->getAllocationsForReuse().peekIsEmpty());
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, MemoryConstants::pageSize64k + 1, 0u);
      EXPECT_NE(allocation, commandStream.getGraphicsAllocation());
      EXPECT_NE(nullptr, commandStream.getGraphicsAllocation());
      EXPECT_FALSE(internalAllocationStorage->getAllocationsForReuse().peekIsEmpty());
  
      memoryManager->freeGraphicsMemory(commandStream.getGraphicsAllocation());
  }
  
  class CommandStreamReceiverWithAubSubCaptureTest : public CommandStreamReceiverTest,
                                                     public ::testing::WithParamInterface<std::pair<bool, bool>> {};
  
  HWTEST_P(CommandStreamReceiverWithAubSubCaptureTest, givenCommandStreamReceiverWhenProgramForAubSubCaptureIsCalledThenProgramCsrDependsOnAubSubCaptureStatus) {
      class MyMockCsr : public MockCommandStreamReceiver {
        public:
          using MockCommandStreamReceiver::MockCommandStreamReceiver;
  
          void initProgrammingFlags() override {
              initProgrammingFlagsCalled = true;
          }
          bool flushBatchedSubmissions() override {
              flushBatchedSubmissionsCalled = true;
              return true;
          }
          bool initProgrammingFlagsCalled = false;
          bool flushBatchedSubmissionsCalled = false;
      };
  
      auto status = GetParam();
      bool wasActiveInPreviousEnqueue = status.first;
      bool isActive = status.second;
  
      MockExecutionEnvironment executionEnvironment;
      executionEnvironment.prepareRootDeviceEnvironments(1);
      executionEnvironment.initializeMemoryManager();
      MyMockCsr mockCsr(executionEnvironment, 0);
  
      mockCsr.programForAubSubCapture(wasActiveInPreviousEnqueue, isActive);
  
      EXPECT_EQ(!wasActiveInPreviousEnqueue && isActive, mockCsr.initProgrammingFlagsCalled);
      EXPECT_EQ(wasActiveInPreviousEnqueue && !isActive, mockCsr.flushBatchedSubmissionsCalled);
  }
  
  std::pair<bool, bool> aubSubCaptureStatus[] = {
      {false, false},
      {false, true},
      {true, false},
      {true, true},
  };
  
  INSTANTIATE_TEST_CASE_P(
      CommandStreamReceiverWithAubSubCaptureTest_program,
      CommandStreamReceiverWithAubSubCaptureTest,
      testing::ValuesIn(aubSubCaptureStatus));
  
  using SimulatedCommandStreamReceiverTest = ::testing::Test;
  
  template <typename FamilyType>
  struct MockSimulatedCsrHw : public CommandStreamReceiverSimulatedHw<FamilyType> {
      using CommandStreamReceiverSimulatedHw<FamilyType>::CommandStreamReceiverSimulatedHw;
      using CommandStreamReceiverSimulatedHw<FamilyType>::getDeviceIndex;
      void pollForCompletion() override {}
      bool writeMemory(GraphicsAllocation &gfxAllocation) override { return true; }
      void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits) override {}
  };
  
  HWTEST_F(SimulatedCommandStreamReceiverTest, givenCsrWithOsContextWhenGetDeviceIndexThenGetHighestEnabledBitInDeviceBitfield) {
      MockExecutionEnvironment executionEnvironment;
      executionEnvironment.prepareRootDeviceEnvironments(1);
      executionEnvironment.initializeMemoryManager();
      MockSimulatedCsrHw<FamilyType> csr(executionEnvironment, 0);
      auto osContext = executionEnvironment.memoryManager->createAndRegisterOsContext(&csr, aub_stream::EngineType::ENGINE_RCS,
                                                                                      0b11, PreemptionMode::Disabled,
                                                                                      false, false, false);
  
      csr.setupContext(*osContext);
      EXPECT_EQ(1u, csr.getDeviceIndex());
  }
  
  HWTEST_F(SimulatedCommandStreamReceiverTest, givenOsContextWithNoDeviceBitfieldWhenGettingDeviceIndexThenZeroIsReturned) {
      MockExecutionEnvironment executionEnvironment;
      executionEnvironment.prepareRootDeviceEnvironments(1);
      executionEnvironment.initializeMemoryManager();
      MockSimulatedCsrHw<FamilyType> csr(executionEnvironment, 0);
      auto osContext = executionEnvironment.memoryManager->createAndRegisterOsContext(&csr, aub_stream::EngineType::ENGINE_RCS,
                                                                                      0b00, PreemptionMode::Disabled,
                                                                                      false, false, false);
  
      csr.setupContext(*osContext);
      EXPECT_EQ(0u, csr.getDeviceIndex());
  }
  
  using CommandStreamReceiverMultiRootDeviceTest = MultiRootDeviceFixture;
  
  TEST_F(CommandStreamReceiverMultiRootDeviceTest, WhenCreatingCommandStreamGraphicsAllocationsThenTheyHaveCorrectRootDeviceIndex) {
      auto commandStreamReceiver = &device->getGpgpuCommandStreamReceiver();
  
      ASSERT_NE(nullptr, commandStreamReceiver);
      EXPECT_EQ(expectedRootDeviceIndex, commandStreamReceiver->getRootDeviceIndex());
  
      // Linear stream / Command buffer
      GraphicsAllocation *allocation = mockMemoryManager->allocateGraphicsMemoryWithProperties({expectedRootDeviceIndex, 128u, GraphicsAllocation::AllocationType::COMMAND_BUFFER});
      LinearStream commandStream{allocation};
  
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 100u, 0u);
      EXPECT_EQ(allocation, commandStream.getGraphicsAllocation());
      EXPECT_EQ(128u, commandStream.getMaxAvailableSpace());
      EXPECT_EQ(expectedRootDeviceIndex, commandStream.getGraphicsAllocation()->getRootDeviceIndex());
  
      commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 1024u, 0u);
      EXPECT_NE(allocation, commandStream.getGraphicsAllocation());
      EXPECT_EQ(0u, commandStream.getMaxAvailableSpace() % MemoryConstants::pageSize64k);
      EXPECT_EQ(expectedRootDeviceIndex, commandStream.getGraphicsAllocation()->getRootDeviceIndex());
      mockMemoryManager->freeGraphicsMemory(commandStream.getGraphicsAllocation());
  
      // Debug surface
      auto debugSurface = commandStreamReceiver->allocateDebugSurface(MemoryConstants::pageSize);
      ASSERT_NE(nullptr, debugSurface);
      EXPECT_EQ(expectedRootDeviceIndex, debugSurface->getRootDeviceIndex());
  
      // Indirect heaps
      IndirectHeap::Type heapTypes[]{IndirectHeap::DYNAMIC_STATE, IndirectHeap::INDIRECT_OBJECT, IndirectHeap::SURFACE_STATE};
      for (auto heapType : heapTypes) {
          IndirectHeap *heap = nullptr;
          commandStreamReceiver->allocateHeapMemory(heapType, MemoryConstants::pageSize, heap);
          ASSERT_NE(nullptr, heap);
          ASSERT_NE(nullptr, heap->getGraphicsAllocation());
          EXPECT_EQ(expectedRootDeviceIndex, heap->getGraphicsAllocation()->getRootDeviceIndex());
          mockMemoryManager->freeGraphicsMemory(heap->getGraphicsAllocation());
          delete heap;
      }
  
      // Tag allocation
      ASSERT_NE(nullptr, commandStreamReceiver->getTagAllocation());
      EXPECT_EQ(expectedRootDeviceIndex, commandStreamReceiver->getTagAllocation()->getRootDeviceIndex());
  
      // Preemption allocation
      if (nullptr == commandStreamReceiver->getPreemptionAllocation()) {
          commandStreamReceiver->createPreemptionAllocation();
      }
      EXPECT_EQ(expectedRootDeviceIndex, commandStreamReceiver->getPreemptionAllocation()->getRootDeviceIndex());
  
      // HostPtr surface
      char memory[8] = {1, 2, 3, 4, 5, 6, 7, 8};
      HostPtrSurface surface(memory, sizeof(memory), true);
      EXPECT_TRUE(commandStreamReceiver->createAllocationForHostSurface(surface, false));
      ASSERT_NE(nullptr, surface.getAllocation());
      EXPECT_EQ(expectedRootDeviceIndex, surface.getAllocation()->getRootDeviceIndex());
  }
  
  using CommandStreamReceiverPageTableManagerTest = ::testing::Test;
  
  TEST_F(CommandStreamReceiverPageTableManagerTest, givenNonDefaultEngineTypeWhenNeedsPageTableManagerIsCalledThenFalseIsReturned) {
      MockExecutionEnvironment executionEnvironment;
      executionEnvironment.initializeMemoryManager();
      MockCommandStreamReceiver commandStreamReceiver(executionEnvironment, 0u);
      auto hwInfo = executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo();
      auto defaultEngineType = getChosenEngineType(*hwInfo);
      auto engineType = aub_stream::EngineType::ENGINE_BCS;
      EXPECT_NE(defaultEngineType, engineType);
      EXPECT_EQ(nullptr, executionEnvironment.rootDeviceEnvironments[0]->pageTableManager.get());
      EXPECT_FALSE(commandStreamReceiver.needsPageTableManager(engineType));
  }
  
  TEST_F(CommandStreamReceiverPageTableManagerTest, givenDefaultEngineTypeAndExistingPageTableManagerWhenNeedsPageTableManagerIsCalledThenFalseIsReturned) {
      MockExecutionEnvironment executionEnvironment;
      executionEnvironment.initializeMemoryManager();
      MockCommandStreamReceiver commandStreamReceiver(executionEnvironment, 0u);
      auto hwInfo = executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo();
      auto defaultEngineType = getChosenEngineType(*hwInfo);
  
      GmmPageTableMngr *dummyPageTableManager = reinterpret_cast<GmmPageTableMngr *>(0x1234);
  
      executionEnvironment.rootDeviceEnvironments[0]->pageTableManager.reset(dummyPageTableManager);
      EXPECT_FALSE(commandStreamReceiver.needsPageTableManager(defaultEngineType));
      executionEnvironment.rootDeviceEnvironments[0]->pageTableManager.release();
  }
  
  TEST_F(CommandStreamReceiverPageTableManagerTest, givenDefaultEngineTypeAndNonExisitingPageTableManagerWhenNeedsPageTableManagerIsCalledThenSupportOfPageTableManagerIsReturned) {
      MockExecutionEnvironment executionEnvironment;
      executionEnvironment.initializeMemoryManager();
      MockCommandStreamReceiver commandStreamReceiver(executionEnvironment, 0u);
      auto hwInfo = executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo();
      auto defaultEngineType = getChosenEngineType(*hwInfo);
      bool supportsPageTableManager = HwHelper::get(hwInfo->platform.eRenderCoreFamily).isPageTableManagerSupported(*hwInfo);
      EXPECT_EQ(nullptr, executionEnvironment.rootDeviceEnvironments[0]->pageTableManager.get());
  
      EXPECT_EQ(supportsPageTableManager, commandStreamReceiver.needsPageTableManager(defaultEngineType));
  }
  