Change command buffer client code to use structures....

command_buffer/client/cross/cmd_buffer_helper_test.cc

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 40 matching lines @@
 // Test fixture for CommandBufferHelper test - Creates a CommandBufferHelper,
 // using a CommandBufferEngine with a mock AsyncAPIInterface for its interface
 // (calling it directly, not through the RPC mechanism).
 class CommandBufferHelperTest : public testing::Test {
  protected:
   virtual void SetUp() {
     api_mock_.reset(new AsyncAPIMock);
     // ignore noops in the mock - we don't want to inspect the internals of the
     // helper.
     EXPECT_CALL(*api_mock_, DoCommand(0, 0, _))
-        .WillRepeatedly(Return(BufferSyncInterface::PARSE_NO_ERROR));
+        .WillRepeatedly(Return(BufferSyncInterface::kParseNoError));
     engine_.reset(new CommandBufferEngine(api_mock_.get()));
     api_mock_->set_engine(engine_.get());
 
     engine_->InitConnection();
     helper_.reset(new CommandBufferHelper(engine_.get()));
     helper_->Init(10);
   }
 
   virtual void TearDown() {
     helper_.release();
@@ skipping 47 matching lines @@
   Sequence sequence_;
 };
 
 // Checks that commands in the buffer are properly executed, and that the
 // status/error stay valid.
 TEST_F(CommandBufferHelperTest, TestCommandProcessing) {
   // Check initial state of the engine - it should have been configured by the
   // helper.
   EXPECT_TRUE(engine()->rpc_impl() != NULL);
   EXPECT_TRUE(engine()->parser() != NULL);
-  EXPECT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   EXPECT_EQ(0, engine()->Get());
 
   // Add 3 commands through the helper
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 1, 0, NULL);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 1, 0, NULL);
 
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 2, 2, args1);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 2, 2, args1);
 
   CommandBufferEntry args2[2];
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 2, args2);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 3, 2, args2);
 
   helper()->Flush();
   // Check that the engine has work to do now.
   EXPECT_FALSE(engine()->parser()->IsEmpty());
 
   // Wait until it's done.
   helper()->Finish();
   // Check that the engine has no more work to do.
   EXPECT_TRUE(engine()->parser()->IsEmpty());
 
   // Check that the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check the error status.
-  ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 }
 
 // Checks that commands in the buffer are properly executed when wrapping the
 // buffer, and that the status/error stay valid.
 TEST_F(CommandBufferHelperTest, TestCommandWrapping) {
   // Add 5 commands of size 3 through the helper to make sure we do wrap.
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
 
   for (unsigned int i = 0; i < 5; ++i) {
-    AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, i+1, 2, args1);
+    AddCommandWithExpect(BufferSyncInterface::kParseNoError, i+1, 2, args1);
   }
 
   helper()->Finish();
   // Check that the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check the error status.
-  ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 }
 
 
 // Checks that commands in the buffer are properly executed, even if they
 // generate a recoverable error. Check that the error status is properly set,
 // and reset when queried.
 TEST_F(CommandBufferHelperTest, TestRecoverableError) {
   CommandBufferEntry args[2];
   args[0].value_uint32 = 3;
   args[1].value_float = 4.f;
 
   // Create a command buffer with 3 commands, 2 of them generating errors
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 1, 2, args);
-  AddCommandWithExpect(BufferSyncInterface::PARSE_UNKNOWN_COMMAND, 2, 2, args);
-  AddCommandWithExpect(BufferSyncInterface::PARSE_INVALID_ARGUMENTS, 3, 2,
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 1, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseUnknownCommand, 2, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseInvalidArguments, 3, 2,
                        args);
 
   helper()->Finish();
   // Check that the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check that the error status was set to the first error.
-  EXPECT_EQ(BufferSyncInterface::PARSE_UNKNOWN_COMMAND,
+  EXPECT_EQ(BufferSyncInterface::kParseUnknownCommand,
             engine()->GetParseError());
   // Check that the error status was reset after the query.
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 
   engine()->CloseConnection();
 }
 
 // Checks that asking for available entries work, and that the parser
 // effectively won't use that space.
 TEST_F(CommandBufferHelperTest, TestAvailableEntries) {
   CommandBufferEntry args[2];
   args[0].value_uint32 = 3;
   args[1].value_float = 4.f;
 
   // Add 2 commands through the helper - 8 entries
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 1, 0, NULL);
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 2, 0, NULL);
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 2, args);
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 4, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 1, 0, NULL);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 2, 0, NULL);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 3, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 4, 2, args);
 
   // Ask for 5 entries.
   helper()->WaitForAvailableEntries(5);
 
   CommandBufferOffset put = get_helper_put();
   CheckFreeSpace(put, 5);
 
   // Add more commands.
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 5, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 5, 2, args);
 
   // Wait until everything is done done.
   helper()->Finish();
 
   // Check that the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check the error status.
-  ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 }
 
 // Checks that the InsertToken/WaitForToken work.
 TEST_F(CommandBufferHelperTest, TestToken) {
   CommandBufferEntry args[2];
   args[0].value_uint32 = 3;
   args[1].value_float = 4.f;
 
   // Add a first command.
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 3, 2, args);
   // keep track of the buffer position.
   CommandBufferOffset command1_put = get_helper_put();
   unsigned int token = helper()->InsertToken();
 
-  EXPECT_CALL(*api_mock(), DoCommand(SET_TOKEN, 1, _))
+  EXPECT_CALL(*api_mock(), DoCommand(kSetToken, 1, _))
       .WillOnce(DoAll(Invoke(api_mock(), &AsyncAPIMock::SetToken),
-                      Return(BufferSyncInterface::PARSE_NO_ERROR)));
+                      Return(BufferSyncInterface::kParseNoError)));
   // Add another command.
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 4, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 4, 2, args);
   helper()->WaitForToken(token);
   // check that the get pointer is beyond the first command.
   EXPECT_LE(command1_put, engine()->Get());
   helper()->Finish();
 
   // Check that the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check the error status.
-  ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 }
 
 }  // namespace command_buffer
 }  // namespace o3d