gpu/command_buffer/service/cmd_parser_test.cc

   1 // Copyright (c) 2011 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 // Tests for the command parser.
   6
   7 #include "base/logging.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "gpu/command_buffer/service/cmd_parser.h"
  10 #include "gpu/command_buffer/service/mocks.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace gpu {
  14
  15 using testing::_;
  16 using testing::Invoke;
  17 using testing::Mock;
  18 using testing::Return;
  19 using testing::Sequence;
  20 using testing::SetArgPointee;
  21 using testing::Truly;
  22
  23 // Test fixture for CommandParser test - Creates a mock AsyncAPIInterface, and
  24 // a fixed size memory buffer. Also provides a simple API to create a
  25 // CommandParser.
  26 class CommandParserTest : public testing::Test {
  27  protected:
  28   virtual void SetUp() {
  29     api_mock_.reset(new AsyncAPIMock(false));
  30     buffer_entry_count_ = 20;
  31     buffer_.reset(new CommandBufferEntry[buffer_entry_count_]);
  32   }
  33   virtual void TearDown() {}
  34
  35   void AddDoCommandsExpect(error::Error _return,
  36                            unsigned int num_commands,
  37                            int num_entries,
  38                            int num_processed) {
  39     EXPECT_CALL(*api_mock_, DoCommands(num_commands, _, num_entries, _))
  40         .InSequence(sequence_)
  41         .WillOnce(DoAll(SetArgPointee<3>(num_processed), Return(_return)));
  42   }
  43
  44   // Creates a parser, with a buffer of the specified size (in entries).
  45   CommandParser *MakeParser(unsigned int entry_count) {
  46     size_t shm_size = buffer_entry_count_ *
  47                       sizeof(CommandBufferEntry);  // NOLINT
  48     size_t command_buffer_size = entry_count *
  49                                  sizeof(CommandBufferEntry);  // NOLINT
  50     DCHECK_LE(command_buffer_size, shm_size);
  51     CommandParser* parser = new CommandParser(api_mock());
  52
  53     parser->SetBuffer(buffer(), shm_size, 0, command_buffer_size);
  54     return parser;
  55   }
  56
  57   unsigned int buffer_entry_count() { return 20; }
  58   AsyncAPIMock *api_mock() { return api_mock_.get(); }
  59   CommandBufferEntry *buffer() { return buffer_.get(); }
  60  private:
  61   unsigned int buffer_entry_count_;
  62   scoped_ptr<AsyncAPIMock> api_mock_;
  63   scoped_ptr<CommandBufferEntry[]> buffer_;
  64   Sequence sequence_;
  65 };
  66
  67 // Tests initialization conditions.
  68 TEST_F(CommandParserTest, TestInit) {
  69   scoped_ptr<CommandParser> parser(MakeParser(10));
  70   EXPECT_EQ(0, parser->get());
  71   EXPECT_EQ(0, parser->put());
  72   EXPECT_TRUE(parser->IsEmpty());
  73 }
  74
  75 // Tests simple commands.
  76 TEST_F(CommandParserTest, TestSimple) {
  77   scoped_ptr<CommandParser> parser(MakeParser(10));
  78   CommandBufferOffset put = parser->put();
  79   CommandHeader header;
  80
  81   // add a single command, no args
  82   header.size = 1;
  83   header.command = 123;
  84   buffer()[put++].value_header = header;
  85   parser->set_put(put);
  86   EXPECT_EQ(put, parser->put());
  87
  88   AddDoCommandsExpect(error::kNoError, 1, 1, 1);
  89   EXPECT_EQ(error::kNoError, parser->ProcessCommands(1));
  90   EXPECT_EQ(put, parser->get());
  91   Mock::VerifyAndClearExpectations(api_mock());
  92
  93   // add a single command, 2 args
  94   header.size = 3;
  95   header.command = 456;
  96   buffer()[put++].value_header = header;
  97   buffer()[put++].value_int32 = 2134;
  98   buffer()[put++].value_float = 1.f;
  99   parser->set_put(put);
 100   EXPECT_EQ(put, parser->put());
 101
 102   AddDoCommandsExpect(error::kNoError, 1, 3, 3);
 103   EXPECT_EQ(error::kNoError, parser->ProcessCommands(1));
 104   EXPECT_EQ(put, parser->get());
 105   Mock::VerifyAndClearExpectations(api_mock());
 106 }
 107
 108 // Tests having multiple commands in the buffer.
 109 TEST_F(CommandParserTest, TestMultipleCommands) {
 110   scoped_ptr<CommandParser> parser(MakeParser(10));
 111   CommandBufferOffset put = parser->put();
 112   CommandHeader header;
 113
 114   // add 2 commands, test with single ProcessCommands()
 115   header.size = 2;
 116   header.command = 789;
 117   buffer()[put++].value_header = header;
 118   buffer()[put++].value_int32 = 5151;
 119
 120   CommandBufferOffset put_cmd2 = put;
 121   header.size = 2;
 122   header.command = 876;
 123   buffer()[put++].value_header = header;
 124   buffer()[put++].value_int32 = 3434;
 125   parser->set_put(put);
 126   EXPECT_EQ(put, parser->put());
 127
 128   // Process up to 1 command.  4 entries remaining.
 129   AddDoCommandsExpect(error::kNoError, 1, 4, 2);
 130   EXPECT_EQ(error::kNoError, parser->ProcessCommands(1));
 131   EXPECT_EQ(put_cmd2, parser->get());
 132
 133   // Process up to 1 command.  2 entries remaining.
 134   AddDoCommandsExpect(error::kNoError, 1, 2, 2);
 135   EXPECT_EQ(error::kNoError, parser->ProcessCommands(1));
 136   EXPECT_EQ(put, parser->get());
 137   Mock::VerifyAndClearExpectations(api_mock());
 138
 139   // add 2 commands again, test with ProcessAllCommands()
 140   header.size = 2;
 141   header.command = 123;
 142   buffer()[put++].value_header = header;
 143   buffer()[put++].value_int32 = 5656;
 144
 145   header.size = 2;
 146   header.command = 321;
 147   buffer()[put++].value_header = header;
 148   buffer()[put++].value_int32 = 7878;
 149   parser->set_put(put);
 150   EXPECT_EQ(put, parser->put());
 151
 152   // 4 entries remaining.
 153   AddDoCommandsExpect(
 154       error::kNoError, CommandParser::kParseCommandsSlice, 4, 4);
 155   EXPECT_EQ(error::kNoError, parser->ProcessAllCommands());
 156   EXPECT_EQ(put, parser->get());
 157   Mock::VerifyAndClearExpectations(api_mock());
 158 }
 159
 160 // Tests that the parser will wrap correctly at the end of the buffer.
 161 TEST_F(CommandParserTest, TestWrap) {
 162   scoped_ptr<CommandParser> parser(MakeParser(5));
 163   CommandBufferOffset put = parser->put();
 164   CommandHeader header;
 165
 166   // add 3 commands with no args (1 word each)
 167   for (unsigned int i = 0; i < 3; ++i) {
 168     header.size = 1;
 169     header.command = i;
 170     buffer()[put++].value_header = header;
 171   }
 172   parser->set_put(put);
 173   EXPECT_EQ(put, parser->put());
 174
 175   // Process up to 10 commands.  3 entries remaining to put.
 176   AddDoCommandsExpect(error::kNoError, 10, 3, 3);
 177   EXPECT_EQ(error::kNoError, parser->ProcessCommands(10));
 178   EXPECT_EQ(put, parser->get());
 179   Mock::VerifyAndClearExpectations(api_mock());
 180
 181   // add 1 command with 1 arg (2 words). That should put us at the end of the
 182   // buffer.
 183   header.size = 2;
 184   header.command = 3;
 185   buffer()[put++].value_header = header;
 186   buffer()[put++].value_int32 = 5;
 187
 188   DCHECK_EQ(5, put);
 189   put = 0;
 190
 191   // add 1 command with 1 arg (2 words).
 192   header.size = 2;
 193   header.command = 4;
 194   buffer()[put++].value_header = header;
 195   buffer()[put++].value_int32 = 6;
 196
 197   // 2 entries remaining to end of buffer.
 198   AddDoCommandsExpect(
 199       error::kNoError, CommandParser::kParseCommandsSlice, 2, 2);
 200   // 2 entries remaining to put.
 201   AddDoCommandsExpect(
 202       error::kNoError, CommandParser::kParseCommandsSlice, 2, 2);
 203   parser->set_put(put);
 204   EXPECT_EQ(put, parser->put());
 205
 206   EXPECT_EQ(error::kNoError, parser->ProcessAllCommands());
 207   EXPECT_EQ(put, parser->get());
 208   Mock::VerifyAndClearExpectations(api_mock());
 209 }
 210
 211 // Tests error conditions.
 212 TEST_F(CommandParserTest, TestError) {
 213   const unsigned int kNumEntries = 5;
 214   scoped_ptr<CommandParser> parser(MakeParser(kNumEntries));
 215   CommandBufferOffset put = parser->put();
 216   CommandHeader header;
 217
 218   EXPECT_FALSE(parser->set_get(-1));
 219   EXPECT_FALSE(parser->set_get(kNumEntries));
 220
 221   // Generate a command with size 0.
 222   header.size = 0;
 223   header.command = 3;
 224   buffer()[put++].value_header = header;
 225
 226   parser->set_put(put);
 227   EXPECT_EQ(put, parser->put());
 228
 229   AddDoCommandsExpect(
 230       error::kInvalidSize, CommandParser::kParseCommandsSlice, 1, 0);
 231   EXPECT_EQ(error::kInvalidSize,
 232             parser->ProcessAllCommands());
 233   // check that no DoCommand call was made.
 234   Mock::VerifyAndClearExpectations(api_mock());
 235
 236   parser.reset(MakeParser(5));
 237   put = parser->put();
 238
 239   // Generate a command with size 6, extends beyond the end of the buffer.
 240   header.size = 6;
 241   header.command = 3;
 242   buffer()[put++].value_header = header;
 243
 244   parser->set_put(put);
 245   EXPECT_EQ(put, parser->put());
 246
 247   AddDoCommandsExpect(
 248       error::kOutOfBounds, CommandParser::kParseCommandsSlice, 1, 0);
 249   EXPECT_EQ(error::kOutOfBounds,
 250             parser->ProcessAllCommands());
 251   // check that no DoCommand call was made.
 252   Mock::VerifyAndClearExpectations(api_mock());
 253
 254   parser.reset(MakeParser(5));
 255   put = parser->put();
 256
 257   // Generates 2 commands.
 258   header.size = 1;
 259   header.command = 3;
 260   buffer()[put++].value_header = header;
 261   CommandBufferOffset put_post_fail = put;
 262   header.size = 1;
 263   header.command = 4;
 264   buffer()[put++].value_header = header;
 265
 266   parser->set_put(put);
 267   EXPECT_EQ(put, parser->put());
 268   // have the first command fail to parse.
 269   AddDoCommandsExpect(
 270       error::kUnknownCommand, CommandParser::kParseCommandsSlice, 2, 1);
 271   EXPECT_EQ(error::kUnknownCommand,
 272             parser->ProcessAllCommands());
 273   // check that only one command was executed, and that get reflects that
 274   // correctly.
 275   EXPECT_EQ(put_post_fail, parser->get());
 276   Mock::VerifyAndClearExpectations(api_mock());
 277   // make the second one succeed, and check that the parser recovered fine.
 278   AddDoCommandsExpect(
 279       error::kNoError, CommandParser::kParseCommandsSlice, 1, 1);
 280   EXPECT_EQ(error::kNoError, parser->ProcessAllCommands());
 281   EXPECT_EQ(put, parser->get());
 282   Mock::VerifyAndClearExpectations(api_mock());
 283 }
 284
 285 TEST_F(CommandParserTest, SetBuffer) {
 286   scoped_ptr<CommandParser> parser(MakeParser(3));
 287   CommandBufferOffset put = parser->put();
 288   CommandHeader header;
 289
 290   // add a single command, no args
 291   header.size = 2;
 292   header.command = 123;
 293   buffer()[put++].value_header = header;
 294   buffer()[put++].value_int32 = 456;
 295   parser->set_put(put);
 296
 297   AddDoCommandsExpect(
 298       error::kNoError, CommandParser::kParseCommandsSlice, 2, 2);
 299   EXPECT_EQ(error::kNoError, parser->ProcessAllCommands());
 300   // We should have advanced 2 entries
 301   EXPECT_EQ(2, parser->get());
 302   Mock::VerifyAndClearExpectations(api_mock());
 303
 304   scoped_ptr<CommandBufferEntry[]> buffer2(new CommandBufferEntry[2]);
 305   parser->SetBuffer(
 306       buffer2.get(), sizeof(CommandBufferEntry) * 2, 0,
 307       sizeof(CommandBufferEntry) * 2);
 308   // The put and get should have reset to 0.
 309   EXPECT_EQ(0, parser->get());
 310   EXPECT_EQ(0, parser->put());
 311 }
 312
 313 }  // namespace gpu