完成了MessageFeildTest, 测得非常细致!

Cpp/Platform/Orm/MessageFieldTest.cc

@@ -1,15 +1,25 @@
 // Copyright 2011 Netease Inc. All Rights Reserved.
 // Author: tanghai@corp.netease.com (tanghai)
 
+#include <sstream>
+#include <boost/make_shared.hpp>
 #include <gtest/gtest.h>
+#include <gmock/gmock.h>
 #include <glog/logging.h>
 #include <gflags/gflags.h>
 #include <google/protobuf/descriptor.h>
 #include "Orm/MessageField.h"
 #include "Orm/Person.pb.h"
+#include "Orm/ResultSetMock.h"
 
 namespace Egametang {
 
+using namespace boost;
+using testing::_;
+using testing::Invoke;
+using testing::Return;
+using testing::An;
+
 class MessageFieldTest: public testing::Test
 {
 };
@@ -161,6 +171,176 @@ TEST_F(MessageFieldTest, GetField_FieldIsMessage)
 	ASSERT_EQ("id: 123 name: \"pen\"", str);
 }
 
+TEST_F(MessageFieldTest, SetField_FieldIsBool)
+{
+	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	EXPECT_CALL(*resultSetMock, getBoolean(7))
+		.WillOnce(Return(true))
+		.WillOnce(Return(false));
+	Person person;
+	const google::protobuf::Descriptor* descriptor = person.GetDescriptor();
+	const google::protobuf::FieldDescriptor* field = descriptor->field(7);
+
+	MessageField messageField(person, field);
+
+	messageField.SetField(resultSetMock);
+	ASSERT_TRUE(person.marry());
+
+	messageField.SetField(resultSetMock);
+	ASSERT_FALSE(person.marry());
+}
+
+TEST_F(MessageFieldTest, SetField_FieldIsDouble)
+{
+	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	EXPECT_CALL(*resultSetMock, getDouble(5))
+		.WillOnce(Return(1.00))
+		.WillOnce(Return(12345.6789));
+	Person person;
+	const google::protobuf::Descriptor* descriptor = person.GetDescriptor();
+	const google::protobuf::FieldDescriptor* field = descriptor->field(5);
+
+	MessageField messageField(person, field);
+
+	messageField.SetField(resultSetMock);
+	ASSERT_FLOAT_EQ(1.00, person.height());
+
+	messageField.SetField(resultSetMock);
+	ASSERT_FLOAT_EQ(12345.6789, person.height());
+}
+
+TEST_F(MessageFieldTest, SetField_FieldIsInt32)
+{
+	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	EXPECT_CALL(*resultSetMock, getInt(1))
+		.WillOnce(Return(1))
+		.WillOnce(Return(0xFFFFFFFF));
+	Person person;
+	const google::protobuf::Descriptor* descriptor = person.GetDescriptor();
+	const google::protobuf::FieldDescriptor* field = descriptor->field(1);
+
+	MessageField messageField(person, field);
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ(1, person.age());
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ(-1, person.age());
+}
+
+TEST_F(MessageFieldTest, SetField_FieldIsInt64)
+{
+	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	EXPECT_CALL(*resultSetMock, getInt64(0))
+		.WillOnce(Return(1))
+		.WillOnce(Return(0xFFFFFFFFFFFFFFFF));
+	Person person;
+	const google::protobuf::Descriptor* descriptor = person.GetDescriptor();
+	const google::protobuf::FieldDescriptor* field = descriptor->field(0);
+
+	MessageField messageField(person, field);
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ(1, person.guid());
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ(-1, person.guid());
+}
+
+TEST_F(MessageFieldTest, SetField_FieldIsUInt32)
+{
+	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	EXPECT_CALL(*resultSetMock, getUInt(2))
+		.WillOnce(Return(1))
+		.WillOnce(Return(0xFFFFFFFF));
+	Person person;
+	const google::protobuf::Descriptor* descriptor = person.GetDescriptor();
+	const google::protobuf::FieldDescriptor* field = descriptor->field(2);
+
+	MessageField messageField(person, field);
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ(1, person.number());
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ(4294967295, person.number());
+}
+
+TEST_F(MessageFieldTest, SetField_FieldIsUInt64)
+{
+	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	EXPECT_CALL(*resultSetMock, getUInt64(3))
+		.WillOnce(Return(1))
+		.WillOnce(Return(0xFFFFFFFFFFFFFFFF));
+	Person person;
+	const google::protobuf::Descriptor* descriptor = person.GetDescriptor();
+	const google::protobuf::FieldDescriptor* field = descriptor->field(3);
+
+	MessageField messageField(person, field);
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ(1, person.time());
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ(18446744073709551615ULL, person.time());
+}
+
+TEST_F(MessageFieldTest, SetField_FieldIsString)
+{
+	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	EXPECT_CALL(*resultSetMock, getString(4))
+		.WillOnce(Return("1"))
+		.WillOnce(Return("tanghai"));
+	Person person;
+	const google::protobuf::Descriptor* descriptor = person.GetDescriptor();
+	const google::protobuf::FieldDescriptor* field = descriptor->field(4);
+
+	MessageField messageField(person, field);
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ("1", person.name());
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ("tanghai", person.name());
+}
+
+TEST_F(MessageFieldTest, SetField_FieldIsBytes)
+{
+	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	EXPECT_CALL(*resultSetMock, getString(6))
+		.WillOnce(Return("1"))
+		.WillOnce(Return("tanghai is a good student"));
+	Person person;
+	const google::protobuf::Descriptor* descriptor = person.GetDescriptor();
+	const google::protobuf::FieldDescriptor* field = descriptor->field(6);
+
+	MessageField messageField(person, field);
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ("1", person.comment());
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ("tanghai is a good student", person.comment());
+}
+
+TEST_F(MessageFieldTest, SetField_FieldIsMessage)
+{
+	std::istringstream is;
+	is.str("id: 123 name: \"pen\"");
+	ResultSetMockPtr resultSetMock = make_shared<ResultSetMock>();
+	EXPECT_CALL(*resultSetMock, getBlob(8))
+		.WillOnce(Return(&is));
+	Person person;
+	const google::protobuf::Descriptor* descriptor = person.GetDescriptor();
+	const google::protobuf::FieldDescriptor* field = descriptor->field(8);
+
+	MessageField messageField(person, field);
+
+	messageField.SetField(resultSetMock);
+	ASSERT_EQ(123, person.item().id());
+	ASSERT_EQ("pen", person.item().name());
+}
+
 } // namespace Egametang
 
 

Cpp/Platform/Orm/OrmTypedef.h

@@ -10,10 +10,12 @@
 namespace Egametang {
 
 class DbResult;
+class ResultSetMock;
 
 typedef boost::shared_ptr<sql::ResultSet> ResultSetPtr;
 typedef boost::shared_ptr<sql::Statement> StatementPtr;
 typedef boost::shared_ptr<DbResult> DbResultPtr;
+typedef boost::shared_ptr<ResultSetMock> ResultSetMockPtr;
 
 } // namespace Egametang
 

Cpp/Platform/Orm/ResultSetMock.h

@@ -0,0 +1,78 @@
+// Copyright: All Rights Reserved
+// Author: egametang@gmail.com (tanghai)
+
+#ifndef ORM_RESULTSETMOCK_H
+#define ORM_RESULTSETMOCK_H
+
+#include <gmock/gmock.h>
+#include <cppconn/resultset.h>
+
+namespace Egametang {
+
+class ResultSetMock: public sql::ResultSet
+{
+public:
+	ResultSetMock()
+	{
+	}
+	MOCK_METHOD1(absolute, bool(int));
+	MOCK_METHOD0(afterLast, void());
+	MOCK_METHOD0(beforeFirst, void());
+	MOCK_METHOD0(cancelRowUpdates, void());
+	MOCK_METHOD0(clearWarnings, void());
+	MOCK_METHOD0(close, void());
+	MOCK_CONST_METHOD1(findColumn, uint32_t(const sql::SQLString&));
+	MOCK_METHOD0(first, bool());
+	MOCK_CONST_METHOD1(getBlob, std::istream*(uint32_t));
+	MOCK_CONST_METHOD1(getBlob, std::istream*(const sql::SQLString&));
+	MOCK_CONST_METHOD1(getBoolean, bool(uint32_t));
+	MOCK_CONST_METHOD1(getBoolean, bool(const sql::SQLString&));
+	MOCK_METHOD0(getConcurrency, int());
+	MOCK_METHOD0(getCursorName, sql::SQLString());
+	MOCK_CONST_METHOD1(getDouble, long double(uint32_t));
+	MOCK_CONST_METHOD1(getDouble, long double(const sql::SQLString&));
+	MOCK_METHOD0(getFetchDirection, int());
+	MOCK_METHOD0(getFetchSize, size_t());
+	MOCK_METHOD0(getHoldability, int());
+	MOCK_CONST_METHOD1(getInt, int32_t(uint32_t));
+	MOCK_CONST_METHOD1(getInt, int32_t(const sql::SQLString&));
+	MOCK_CONST_METHOD1(getUInt, uint32_t(uint32_t));
+	MOCK_CONST_METHOD1(getUInt, uint32_t(const sql::SQLString&));
+	MOCK_CONST_METHOD1(getInt64, int64_t(uint32_t));
+	MOCK_CONST_METHOD1(getInt64, int64_t(const sql::SQLString&));
+	MOCK_CONST_METHOD1(getUInt64, uint64_t(uint32_t));
+	MOCK_CONST_METHOD1(getUInt64, uint64_t(const sql::SQLString&));
+	MOCK_CONST_METHOD0(getMetaData, sql::ResultSetMetaData*());
+	MOCK_CONST_METHOD0(getRow, size_t());
+	MOCK_METHOD1(getRowId, sql::RowID*(uint32_t));
+	MOCK_METHOD1(getRowId, sql::RowID*(const sql::SQLString&));
+	MOCK_CONST_METHOD0(getStatement, const sql::Statement*());
+	MOCK_CONST_METHOD1(getString, sql::SQLString(uint32_t));
+	MOCK_CONST_METHOD1(getString, sql::SQLString(const sql::SQLString&));
+	MOCK_CONST_METHOD0(getType, enum_type());
+	MOCK_METHOD0(getWarnings, void());
+	MOCK_METHOD0(insertRow, void());
+	MOCK_CONST_METHOD0(isAfterLast, bool());
+	MOCK_CONST_METHOD0(isBeforeFirst, bool());
+	MOCK_CONST_METHOD0(isClosed, bool());
+	MOCK_CONST_METHOD0(isFirst, bool());
+	MOCK_CONST_METHOD0(isLast, bool());
+	MOCK_CONST_METHOD1(isNull, bool(uint32_t));
+	MOCK_CONST_METHOD1(isNull, bool(const sql::SQLString&));
+	MOCK_METHOD0(last, bool());
+	MOCK_METHOD0(next, bool());
+	MOCK_METHOD0(moveToCurrentRow, void());
+	MOCK_METHOD0(moveToInsertRow, void());
+	MOCK_METHOD0(previous, bool());
+	MOCK_METHOD0(refreshRow, void());
+	MOCK_METHOD1(relative, bool(int));
+	MOCK_METHOD0(rowDeleted, bool());
+	MOCK_METHOD0(rowInserted, bool());
+	MOCK_METHOD0(rowUpdated, bool());
+	MOCK_METHOD1(setFetchSize, void(size_t));
+	MOCK_CONST_METHOD0(rowsCount, size_t());
+	MOCK_CONST_METHOD0(wasNull, bool());
+};
+
+} // namespace Egametang
+#endif // ORM_RESULTSETMOCK_H