Home | History | Annotate | Download | only in service
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
      6 
      7 #include "base/memory/scoped_ptr.h"
      8 #include "testing/gtest/include/gtest/gtest.h"
      9 #include "testing/gmock/include/gmock/gmock.h"
     10 
     11 using base::SharedMemory;
     12 
     13 namespace gpu {
     14 
     15 const static size_t kBufferSize = 1024;
     16 
     17 class TransferBufferManagerTest : public testing::Test {
     18  protected:
     19   virtual void SetUp() {
     20     for (size_t i = 0; i < arraysize(buffers_); ++i) {
     21       buffers_[i].CreateAnonymous(kBufferSize);
     22       buffers_[i].Map(kBufferSize);
     23     }
     24 
     25     TransferBufferManager* manager = new TransferBufferManager();
     26     transfer_buffer_manager_.reset(manager);
     27     ASSERT_TRUE(manager->Initialize());
     28   }
     29 
     30   base::SharedMemory buffers_[3];
     31   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
     32 };
     33 
     34 TEST_F(TransferBufferManagerTest, ZeroHandleMapsToNull) {
     35   EXPECT_TRUE(NULL == transfer_buffer_manager_->GetTransferBuffer(0).ptr);
     36 }
     37 
     38 TEST_F(TransferBufferManagerTest, NegativeHandleMapsToNull) {
     39   EXPECT_TRUE(NULL == transfer_buffer_manager_->GetTransferBuffer(-1).ptr);
     40 }
     41 
     42 TEST_F(TransferBufferManagerTest, OutOfRangeHandleMapsToNull) {
     43   EXPECT_TRUE(NULL == transfer_buffer_manager_->GetTransferBuffer(1).ptr);
     44 }
     45 
     46 TEST_F(TransferBufferManagerTest, CanRegisterTransferBuffer) {
     47   EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(1,
     48                                                                &buffers_[0],
     49                                                                kBufferSize));
     50   Buffer registered = transfer_buffer_manager_->GetTransferBuffer(1);
     51 
     52   // Distinct memory range and shared memory handle from that originally
     53   // registered.
     54   EXPECT_NE(static_cast<void*>(NULL), registered.ptr);
     55   EXPECT_NE(buffers_[0].memory(), registered.ptr);
     56   EXPECT_EQ(kBufferSize, registered.size);
     57   EXPECT_NE(&buffers_[0], registered.shared_memory);
     58 
     59   // But maps to the same physical memory.
     60   *static_cast<int*>(registered.ptr) = 7;
     61   *static_cast<int*>(buffers_[0].memory()) = 8;
     62   EXPECT_EQ(8, *static_cast<int*>(registered.ptr));
     63 }
     64 
     65 TEST_F(TransferBufferManagerTest, CanDestroyTransferBuffer) {
     66   EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(1,
     67                                                                &buffers_[0],
     68                                                                kBufferSize));
     69   transfer_buffer_manager_->DestroyTransferBuffer(1);
     70   Buffer registered = transfer_buffer_manager_->GetTransferBuffer(1);
     71 
     72   EXPECT_EQ(static_cast<void*>(NULL), registered.ptr);
     73   EXPECT_EQ(0U, registered.size);
     74   EXPECT_EQ(static_cast<base::SharedMemory*>(NULL), registered.shared_memory);
     75 }
     76 
     77 TEST_F(TransferBufferManagerTest, CannotRegregisterTransferBufferId) {
     78   EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(1,
     79                                                                &buffers_[0],
     80                                                                kBufferSize));
     81   EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(1,
     82                                                                 &buffers_[0],
     83                                                                 kBufferSize));
     84   EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(1,
     85                                                                 &buffers_[1],
     86                                                                 kBufferSize));
     87 }
     88 
     89 TEST_F(TransferBufferManagerTest, CanReuseTransferBufferIdAfterDestroying) {
     90   EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(1,
     91                                                                &buffers_[0],
     92                                                                kBufferSize));
     93   transfer_buffer_manager_->DestroyTransferBuffer(1);
     94   EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(1,
     95                                                                &buffers_[1],
     96                                                                kBufferSize));
     97 }
     98 
     99 TEST_F(TransferBufferManagerTest, DestroyUnusedTransferBufferIdDoesNotCrash) {
    100   transfer_buffer_manager_->DestroyTransferBuffer(1);
    101 }
    102 
    103 TEST_F(TransferBufferManagerTest, CannotRegisterNullTransferBuffer) {
    104   EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(0,
    105                                                                 &buffers_[0],
    106                                                                 kBufferSize));
    107 }
    108 
    109 TEST_F(TransferBufferManagerTest, CannotRegisterNegativeTransferBufferId) {
    110   EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(-1,
    111                                                                 &buffers_[0],
    112                                                                 kBufferSize));
    113 }
    114 
    115 }  // namespace gpu
    116