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

command_buffer/service/cross/cmd_buffer_engine_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 115 matching lines @@
   unsigned int shm_id_;
   Sequence sequence_;
 };
 
 // Tests the initialization/termination sequence, checking that it sets the
 // engine in the correct states.
 TEST_F(CommandBufferEngineTest, TestInitialization) {
   // Check initial state
   EXPECT_TRUE(engine()->rpc_impl() != NULL);
   EXPECT_TRUE(engine()->parser() == NULL);
-  EXPECT_EQ(BufferSyncInterface::NOT_CONNECTED, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kNotConnected, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   EXPECT_EQ(-1, engine()->Get());
   EXPECT_EQ(0, engine()->GetToken());
 
   engine()->InitConnection();
-  EXPECT_EQ(BufferSyncInterface::NO_BUFFER, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kNoBuffer, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   EXPECT_EQ(-1, engine()->Get());
 
   CommandBufferEntry *entries = InitCommandBuffer(25, 5);
   ASSERT_TRUE(entries != 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(5, engine()->Get());
   EXPECT_TRUE(engine()->parser() != NULL);
 
   engine()->set_token(5678);
   EXPECT_EQ(5678, engine()->GetToken());
 
   engine()->CloseConnection();
   DestroyCommandBuffer();
 
-  EXPECT_EQ(BufferSyncInterface::NOT_CONNECTED, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kNotConnected, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   EXPECT_EQ(-1, engine()->Get());
   EXPECT_TRUE(engine()->parser() == NULL);
 }
 
 // Checks that shared memory registration works.
 TEST_F(CommandBufferEngineTest, TestSharedMemoryRegistration) {
   // Create and register a first shared memory buffer.
   const size_t kShmSize1 = 10;
   RPCShmHandle shm1 = CreateShm(kShmSize1);
   ASSERT_NE(kRPCInvalidHandle, shm1);
@@ skipping 52 matching lines @@
 TEST_F(CommandBufferEngineTest, TestCommandProcessing) {
   engine()->InitConnection();
   CommandBufferEntry *entries = InitCommandBuffer(10, 0);
   ASSERT_TRUE(entries != NULL);
 
   CommandBufferOffset get = engine()->Get();
   CommandBufferOffset put = get;
 
   // Create a command buffer with 3 commands
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
 
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
 
   CommandBufferEntry args2[2];
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               2,
                               2,
                               args2);
 
   engine()->Put(put);
   while (get != put) {
     // Check that the parsing progresses, and that no error occurs.
     CommandBufferOffset new_get = engine()->WaitGetChanges(get);
     EXPECT_NE(get, new_get);
-    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());
     EXPECT_EQ(new_get, engine()->Get());
     get = new_get;
   }
   // Check that the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock());
 
   engine()->CloseConnection();
   DestroyCommandBuffer();
 }
 
 // Checks that commands in the buffer are properly executed when wrapping the
 // buffer, and that the status/error stay valid.
 TEST_F(CommandBufferEngineTest, TestCommandWrapping) {
   engine()->InitConnection();
   CommandBufferEntry *entries = InitCommandBuffer(10, 6);
   ASSERT_TRUE(entries != NULL);
 
   CommandBufferOffset get = engine()->Get();
   CommandBufferOffset put = get;
 
   // Create a command buffer with 3 commands
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
 
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
   DCHECK_EQ(10, put);
   put = 0;
 
   CommandBufferEntry args2[2];
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               2,
                               2,
                               args2);
 
   engine()->Put(put);
   while (get != put) {
     // Check that the parsing progresses, and that no error occurs.
     CommandBufferOffset new_get = engine()->WaitGetChanges(get);
     EXPECT_NE(get, new_get);
-    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());
     EXPECT_EQ(new_get, engine()->Get());
     get = new_get;
   }
   // Check that the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock());
 
   engine()->CloseConnection();
   DestroyCommandBuffer();
 }
 
 // Checks that commands in the buffer are properly executed when we change the
 // buffer, and when we close the connection.
 TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) {
   engine()->InitConnection();
   CommandBufferEntry *entries = InitCommandBuffer(10, 0);
   ASSERT_TRUE(entries != NULL);
 
   CommandBufferOffset get = engine()->Get();
   CommandBufferOffset put = get;
 
   // Create a command buffer with 3 commands
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
 
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
 
   CommandBufferEntry args2[2];
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               2,
                               2,
                               args2);
 
   engine()->Put(put);
 
   // Setup a new buffer.
   const size_t kShmSize = 10 * sizeof(CommandBufferEntry);  // NOLINT
   RPCShmHandle shm = CreateShm(kShmSize);
   ASSERT_NE(kRPCInvalidHandle, shm);
   unsigned int shm_id = engine()->RegisterSharedMemory(shm, kShmSize);
   ASSERT_NE(BufferSyncInterface::kInvalidSharedMemoryId, shm_id);
   CommandBufferEntry *entries2 = static_cast<CommandBufferEntry *>(
       engine()->GetSharedMemoryAddress(shm_id));
   engine()->SetCommandBuffer(shm_id, 0, kShmSize, 0);
-  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());
 
   // Destroy the old command buffer.
   DestroyCommandBuffer();
 
   get = engine()->Get();
   put = get;
   put += AddCommandWithExpect(entries2 + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
 
   engine()->Put(put);
 
   engine()->CloseConnection();
   // Check that all the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock());
 
   engine()->UnregisterSharedMemory(shm_id);
   DestroyShm(shm);
 }
 
 // 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(CommandBufferEngineTest, TestRecoverableError) {
   engine()->InitConnection();
   CommandBufferEntry *entries = InitCommandBuffer(10, 0);
   ASSERT_TRUE(entries != NULL);
 
   CommandBufferOffset get = engine()->Get();
   CommandBufferOffset put = get;
 
   // Create a command buffer with 3 commands, 2 of them generating errors
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
 
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_INVALID_ARGUMENTS,
+                              BufferSyncInterface::kParseInvalidArguments,
                               1,
                               2,
                               args1);
 
   CommandBufferEntry args2[2];
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_UNKNOWN_COMMAND,
+                              BufferSyncInterface::kParseUnknownCommand,
                               2,
                               2,
                               args2);
 
   engine()->Put(put);
   while (get != put) {
     // Check that the parsing progresses, and that no error occurs.
     CommandBufferOffset new_get = engine()->WaitGetChanges(get);
     EXPECT_NE(get, new_get);
-    ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
+    ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
     EXPECT_EQ(new_get, engine()->Get());
     get = new_get;
   }
   // 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_INVALID_ARGUMENTS,
+  EXPECT_EQ(BufferSyncInterface::kParseInvalidArguments,
             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();
   DestroyCommandBuffer();
 }
 
 // Checks that commands in the buffer are properly executed up to the point
 // where a parsing error happened. Check that at that point the status and
 // error are properly set.
 TEST_F(CommandBufferEngineTest, TestNonRecoverableError) {
   engine()->InitConnection();
   // Create a buffer with 6 entries, starting at entry 1, but allocate enough
   // memory so that we can add commands that cross over the limit.
   const size_t kShmSize = 10 * sizeof(CommandBufferEntry);  // NOLINT
   RPCShmHandle shm = CreateShm(kShmSize);
   ASSERT_NE(kRPCInvalidHandle, shm);
   unsigned int shm_id = engine()->RegisterSharedMemory(shm, kShmSize);
   ASSERT_NE(BufferSyncInterface::kInvalidSharedMemoryId, shm_id);
   CommandBufferEntry *entries = static_cast<CommandBufferEntry *>(
       engine()->GetSharedMemoryAddress(shm_id));
   ASSERT_TRUE(entries != NULL);
   engine()->SetCommandBuffer(shm_id, 0, 6 * sizeof(CommandBufferEntry), 1);
 
   CommandBufferOffset get = engine()->Get();
   CommandBufferOffset put = get;
 
   // Create a command buffer with 3 commands, the last one overlapping the end
   // of the buffer.
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
 
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
 
   CommandBufferOffset fail_get = put;
   CommandHeader header;
   header.size = 3;
   header.command = 4;
   entries[put++].value_header = header;
   entries[put++].value_uint32 = 5;
   entries[put++].value_uint32 = 6;
 
   // we should be beyond the end of the buffer now.
   DCHECK_LT(6, put);
   put = 0;
 
   engine()->Put(put);
   while (get != put) {
     // When the parsing stop progressing, break.
     CommandBufferOffset new_get = engine()->WaitGetChanges(get);
     if (new_get == get) {
       EXPECT_EQ(new_get, engine()->Get());
       break;
     }
     get = new_get;
   }
   // We should be in an error case now.
-  EXPECT_EQ(BufferSyncInterface::PARSE_ERROR, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseError, engine()->GetStatus());
   // Check that the error status was set to the first error.
-  EXPECT_EQ(BufferSyncInterface::PARSE_OUT_OF_BOUNDS,
+  EXPECT_EQ(BufferSyncInterface::kParseOutOfBounds,
             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());
 
   // Check that the valid commands did happen.
   Mock::VerifyAndClearExpectations(api_mock());
 
   engine()->CloseConnection();
   engine()->UnregisterSharedMemory(shm_id);
   DestroyShm(shm);
 }
 
 // Checks that HasWork() and DoWork() have the correct semantics. If there is
@@ skipping 28 matching lines @@
   }
   EXPECT_EQ(0, process_mock()->message_count());
   EXPECT_FALSE(process_mock()->would_have_blocked());
   Mock::VerifyAndClearExpectations(process_mock());
 
   // Test that if we have commands, we will process them without blocking.
   // Create a command buffer with 3 commands
   process_mock()->Reset();
   EXPECT_CALL(*process_mock(), HasMessage()).Times(AnyNumber());
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
 
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
 
   CommandBufferEntry args2[2];
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               2,
                               2,
                               args2);
 
   EXPECT_FALSE(engine()->HasWork());  // No work yet, until we change put
 
   engine()->Put(put);
   EXPECT_TRUE(engine()->HasWork());
 
   EXPECT_CALL(*process_mock(), ProcessMessage()).Times(0);
   while (engine()->HasWork()) {
     EXPECT_TRUE(engine()->DoWork());
   }
   EXPECT_FALSE(process_mock()->would_have_blocked());
   get = engine()->Get();
   EXPECT_EQ(put, get);  // once we're done, we should have executed everything.
-  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());
   Mock::VerifyAndClearExpectations(process_mock());
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Test that the engine stops if we send it a "kill" message.
   process_mock()->Reset();
   EXPECT_CALL(*process_mock(), HasMessage()).Times(AnyNumber());
   process_mock()->set_message_count(1);
   EXPECT_TRUE(engine()->HasWork());
 
   EXPECT_CALL(*process_mock(), ProcessMessage()).WillOnce(Return(false));
   EXPECT_FALSE(engine()->DoWork());
   Mock::VerifyAndClearExpectations(process_mock());
 
   engine()->CloseConnection();
   DestroyCommandBuffer();
 }
 
 }  // namespace command_buffer
 }  // namespace o3d