| /* $Id$
|
| * Licensed to the Apache Software Foundation (ASF) under one or more
|
| * contributor license agreements. See the NOTICE file distributed with
|
| * this work for additional information regarding copyright ownership.
|
| * The ASF licenses this file to you under the Apache License, Version
|
| * 2.0 (the "License"); you may not use this file except in compliance
|
| * with the License. You may obtain a copy of the License at
|
| *
|
| * http://www.apache.org/licenses/LICENSE-2.0
|
| *
|
| * Unless required by applicable law or agreed to in writing, software
|
| * distributed under the License is distributed on an "AS IS" BASIS,
|
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
| * See the License for the specific language governing permissions and
|
| * limitations under the License.
|
| */
|
| #include <gtest/gtest.h>
|
| #include <gmock/gmock.h>
|
| #include "serialization/EtchDefaultValueFactory.h"
|
| #include "serialization/EtchBinaryTaggedData.h"
|
| #include "serialization/EtchBinaryTaggedDataInput.h"
|
| #include "serialization/EtchValidatorShort.h"
|
| #include "transport/EtchMessagizer.h"
|
| #include "transport/EtchTcpConnection.h"
|
| #include "transport/EtchPacketizer.h"
|
| #include "transport/EtchSessionListener.h"
|
| #include "transport/EtchTcpListener.h"
|
|
|
|
|
| class MockListener11 : public virtual EtchSessionListener<EtchSocket> {
|
| public:
|
|
|
| MockListener11(EtchTransport<EtchSessionListener<EtchSocket> >* transport) |
| : mTransport(transport) { |
| if(mTransport != NULL) { |
| mTransport->setSession(this); |
| } |
| } |
| |
| virtual ~MockListener11() { |
| if(mTransport != NULL) { |
| delete mTransport; |
| } |
| } |
|
|
| //This method is called |
| status_t sessionAccepted(EtchSocket* connection) {
|
| delete connection;
|
| return ETCH_OK;
|
| }
|
|
|
| MOCK_METHOD2(sessionQuery, status_t(capu::SmartPointer<EtchObject> query, capu::SmartPointer<EtchObject> &result));
|
|
|
| MOCK_METHOD2(sessionControl, status_t(capu::SmartPointer<EtchObject> control, capu::SmartPointer<EtchObject> value));
|
|
|
| status_t sessionNotify(capu::SmartPointer<EtchObject> event) { |
| return ETCH_OK; |
| } |
| |
| private: |
| EtchTransport<EtchSessionListener<EtchSocket> >* mTransport; |
| };
|
|
|
| class MockMailboxManager : public EtchSessionMessage {
|
| public:
|
|
|
| status_t sessionMessage(capu::SmartPointer<EtchWho> receipent, capu::SmartPointer<EtchMessage> buf) {
|
| EXPECT_TRUE(buf->count() == 1);
|
| buf->clear(); |
| return ETCH_OK;
|
| }
|
|
|
| MOCK_METHOD2(sessionQuery, status_t(capu::SmartPointer<EtchObject> query, capu::SmartPointer<EtchObject> &result));
|
|
|
| MOCK_METHOD2(sessionControl, status_t(capu::SmartPointer<EtchObject> control, capu::SmartPointer<EtchObject> value));
|
|
|
| status_t sessionNotify(capu::SmartPointer<EtchObject> event) { |
| return ETCH_OK; |
| } |
| };
|
|
|
| class EtchMessagizerTest
|
| : public ::testing::Test {
|
| protected:
|
| virtual void SetUp() {
|
| mRuntime = new EtchRuntime();
|
| mRuntime->setLogger(new EtchLogger());
|
| mRuntime->start();
|
| }
|
|
|
| virtual void TearDown() {
|
| mRuntime->shutdown();
|
| EtchLogger* logger = mRuntime->getLogger();
|
| if(logger != NULL) {
|
| delete logger;
|
| }
|
| delete mRuntime;
|
| mRuntime = NULL;
|
| }
|
|
|
| EtchRuntime* mRuntime;
|
| };
|
|
|
| TEST_F(EtchMessagizerTest, constructorTest) {
|
| EtchTypeMap types;
|
| EtchClass2TypeMap class2type;
|
| EtchDefaultValueFactory * factory;
|
| EtchDefaultValueFactory::Init(&types, &class2type);
|
| EtchString uri("tcp://127.0.0.1:4001");
|
| factory = new EtchDefaultValueFactory(uri, &types, &class2type);
|
| //created value factory
|
| EtchURL u("tcp://127.0.0.1:4001");
|
| EtchResources r;
|
| EtchObject *out;
|
| r.put(EtchTransport<EtchSessionMessage>::VALUE_FACTORY(), factory, out); |
| EtchTransportData* conn = new EtchTcpConnection(mRuntime, NULL, &u);
|
| EtchTransportPacket* pac = new EtchPacketizer(conn, &u);
|
| EtchSessionPacket* mes = new EtchMessagizer(pac, &u, &r);
|
| //Created stack
|
| delete mes;
|
| delete factory;
|
| types.clear();
|
| }
|
|
|
| TEST_F(EtchMessagizerTest, TransportControlTest) {
|
| EtchTypeMap types;
|
| EtchClass2TypeMap class2type;
|
| EtchDefaultValueFactory * factory;
|
| MockMailboxManager manager; |
| EtchDefaultValueFactory::Init(&types, &class2type);
|
| EtchString uri("tcp://127.0.0.1:4001");
|
| factory = new EtchDefaultValueFactory(uri, &types, &class2type);
|
| //created value factory
|
| EtchURL u("tcp://127.0.0.1:4001");
|
| EtchResources r;
|
| EtchObject *out;
|
| r.put(EtchTransport<EtchSessionMessage>::VALUE_FACTORY(), factory, out); |
| EtchTransportData* conn = new EtchTcpConnection(mRuntime, NULL, &u);
|
| EtchPacketizer* pac = new EtchPacketizer(conn, &u);
|
| EtchMessagizer* mess = new EtchMessagizer(pac, &u, &r);
|
| mess->setSession(&manager); |
|
|
| EtchTcpListener* transport = new EtchTcpListener(&u); |
| EtchSessionListener<EtchSocket>* mSessionListener = new MockListener11(transport); |
| |
| transport->transportControl(new EtchString(EtchTcpListener::START_AND_WAIT_UP()), new EtchInt32(1000)); |
| |
| mess->transportControl(new EtchString(EtchPacketizer::START_AND_WAIT_UP()), new EtchInt32(1000)); |
| //test transport commands
|
| mess->transportControl(new EtchString(EtchPacketizer::STOP_AND_WAIT_DOWN()), new EtchInt32(1000)); |
| |
| transport->transportControl(new EtchString(EtchTcpListener::STOP_AND_WAIT_DOWN()), new EtchInt32(1000)); |
|
|
| delete mSessionListener;
|
| delete mess;
|
| delete factory;
|
| types.clear();
|
| }
|
|
|
| TEST_F(EtchMessagizerTest, TransportMessageTest) {
|
| EtchTypeMap types;
|
| EtchClass2TypeMap class2type;
|
| EtchDefaultValueFactory * factory;
|
| MockMailboxManager manager; |
| EtchDefaultValueFactory::Init(&types, &class2type);
|
| EtchString uri("tcp://127.0.0.1:4001");
|
| factory = new EtchDefaultValueFactory(uri, &types, &class2type);
|
| //default value factory
|
| EtchURL u("tcp://127.0.0.1:4001");
|
| EtchResources r;
|
| EtchObject *out;
|
| //add to the resource
|
| r.put(EtchTransport<EtchSessionMessage>::VALUE_FACTORY(), factory, out); |
| EtchTransportData* conn = new EtchTcpConnection(mRuntime, NULL, &u);
|
| EtchPacketizer* pac = new EtchPacketizer(conn, &u);
|
| EtchMessagizer* mess = new EtchMessagizer(pac, &u, &r);
|
| mess->setSession(&manager); |
| //creation of example message which will be serialized
|
| EtchType *mt_foo = NULL;
|
| EtchField mf_x("x");
|
| EtchString str("foo");
|
| factory->getType(str, mt_foo);
|
| capu::SmartPointer<EtchValidator> v;
|
| EtchValidatorShort::Get(0, v);
|
| mt_foo->putValidator(mf_x, v);
|
| capu::SmartPointer<EtchShort> data = new EtchShort(10000);
|
| capu::SmartPointer<EtchMessage> msg = new EtchMessage(mt_foo, factory);
|
| msg->put(mf_x, data);
|
|
|
| EXPECT_TRUE(mess->transportMessage(NULL, msg) == ETCH_ERROR); |
|
|
| delete mess;
|
| delete factory;
|
| types.clear();
|
| }
|
|
|
| TEST_F(EtchMessagizerTest, SessionDataTest) {
|
| //creation of an example message to compare the deserialized messageMyValueFactory vf("tcp:");
|
| EtchTypeMap types;
|
| EtchClass2TypeMap class2type;
|
| EtchString name1("a");
|
| EtchString name2("b");
|
| EtchType *mt_foo = new EtchType(1, name1);
|
| EtchField mf_x(2, name2);
|
| capu::SmartPointer<EtchValidator> v;
|
| EtchValidatorShort::Get(0, v);
|
| mt_foo->putValidator(mf_x, v);
|
| types.add(mt_foo);
|
| capu::SmartPointer<EtchShort> data = new EtchShort(10000);
|
| //default value factory
|
| EtchDefaultValueFactory * factory;
|
| EtchDefaultValueFactory::Init(&types, &class2type);
|
| EtchString uri("tcp://127.0.0.1:4001");
|
|
|
|
|
| factory = new EtchDefaultValueFactory(uri, &types, &class2type);
|
| capu::SmartPointer<EtchMessage> msg = new EtchMessage(mt_foo, factory);
|
| msg->put(mf_x, data);
|
|
|
|
|
| EtchURL u(uri);
|
| EtchResources r;
|
| EtchObject *out;
|
| //add the value factory to the resources
|
| r.put(EtchTransport<EtchSessionMessage>::VALUE_FACTORY(), factory, out); |
| //create stack
|
| EtchTransportData* conn = new EtchTcpConnection(mRuntime, NULL, &u);
|
| EtchPacketizer* pac = new EtchPacketizer(conn, &u);
|
| EtchMessagizer* mess = new EtchMessagizer(pac, &u, &r);
|
| capu::SmartPointer<EtchFlexBuffer> buffer = new EtchFlexBuffer();
|
|
|
| //A packet is created
|
| capu::int8_t byte_pos[] = {3, 1, 1, 2, -123, 39, 16, -127};
|
| buffer->setByteRepresentation(ETCH_BIG_ENDIAN);
|
| buffer->put((capu::int8_t *)"_header_", pac->getHeaderSize());
|
| buffer->put((capu::int8_t *)byte_pos, 8);
|
| buffer->setIndex(0);
|
| capu::int32_t pktsize = buffer->getLength() - pac->getHeaderSize();
|
| buffer->put((capu::int8_t *) & pac->SIG, sizeof (capu::int32_t));
|
| buffer->put((capu::int8_t *) & pktsize, sizeof (capu::int32_t));
|
| buffer->setIndex(pac->getHeaderSize());
|
| EXPECT_TRUE(buffer->getLength() == 16);
|
|
|
| //Simulate call with fake package
|
| EtchSessionMessage* mMailboxManager = new MockMailboxManager();
|
| mess->setSession(mMailboxManager);
|
| EXPECT_TRUE(mess->sessionPacket(NULL, buffer) == ETCH_OK);
|
|
|
| mess->setSession(NULL);
|
| types.clear();
|
| delete mMailboxManager;
|
| delete mess;
|
| delete factory;
|
| }
|