updating VR test cases

lib/udptransport.cc

@@ -29,10 +29,10 @@
  *
  **********************************************************************/
 
-#include "paxos-lib/lib/assert.h"
-#include "paxos-lib/lib/configuration.h"
-#include "paxos-lib/lib/message.h"
-#include "paxos-lib/lib/udptransport.h"
+#include "lib/assert.h"
+#include "lib/configuration.h"
+#include "lib/message.h"
+#include "lib/udptransport.h"
 
 #include <google/protobuf/message.h>
 #include <event2/event.h>
@@ -83,7 +83,7 @@ bool operator<(const UDPTransportAddress &a, const UDPTransportAddress &b)
 }
 
 UDPTransportAddress
-UDPTransport::LookupAddress(const replication::ReplicaAddress &addr)
+UDPTransport::LookupAddress(const transport::ReplicaAddress &addr)
 {
     int res;
     struct addrinfo hints;
@@ -106,15 +106,15 @@ UDPTransport::LookupAddress(const replication::ReplicaAddress &addr)
 }
 
 UDPTransportAddress
-UDPTransport::LookupAddress(const replication::Configuration &config,
+UDPTransport::LookupAddress(const transport::Configuration &config,
                             int idx)
 {
-    const replication::ReplicaAddress &addr = config.replica(idx);
+    const transport::ReplicaAddress &addr = config.replica(idx);
     return LookupAddress(addr);
 }
 
 const UDPTransportAddress *
-UDPTransport::LookupMulticastAddress(const replication::Configuration
+UDPTransport::LookupMulticastAddress(const transport::Configuration
                                      *config)
 {
     if (!config->multicast()) {
@@ -232,7 +232,7 @@ UDPTransport::~UDPTransport()
 }
 
 void
-UDPTransport::ListenOnMulticastPort(const replication::Configuration
+UDPTransport::ListenOnMulticastPort(const transport::Configuration
                                     *canonicalConfig)
 {
     if (!canonicalConfig->multicast()) {
@@ -298,13 +298,13 @@ UDPTransport::ListenOnMulticastPort(const replication::Configuration
 
 void
 UDPTransport::Register(TransportReceiver *receiver,
-                       const replication::Configuration &config,
+                       const transport::Configuration &config,
                        int replicaIdx)
 {
     ASSERT(replicaIdx < config.n);
     struct sockaddr_in sin;
 
-    const replication::Configuration *canonicalConfig =
+    const transport::Configuration *canonicalConfig =
         RegisterConfiguration(receiver, config, replicaIdx);
 
     // Create socket
@@ -624,7 +624,7 @@ UDPTransport::OnReadable(int fd)
             // If so, deliver the message to all replicas for that
             // config, *except* if that replica was the sender of the
             // message.
-            const replication::Configuration *cfg = it->second;
+            const transport::Configuration *cfg = it->second;
             for (auto &kv : replicaReceivers[cfg]) {
                 TransportReceiver *receiver = kv.second;
                 const UDPTransportAddress &raddr = 

lib/udptransport.h

@@ -32,9 +32,9 @@
 #ifndef _LIB_UDPTRANSPORT_H_
 #define _LIB_UDPTRANSPORT_H_
 
-#include "paxos-lib/lib/configuration.h"
-#include "paxos-lib/lib/transport.h"
-#include "paxos-lib/lib/transportcommon.h"
+#include "lib/configuration.h"
+#include "lib/transport.h"
+#include "lib/transportcommon.h"
 
 #include <event2/event.h>
 
@@ -69,7 +69,7 @@ public:
                  int dscp = 0, event_base *evbase = nullptr);
     virtual ~UDPTransport();
     void Register(TransportReceiver *receiver,
-                  const replication::Configuration &config,
+                  const transport::Configuration &config,
                   int replicaIdx);
     void Run();
     void Stop();
@@ -106,8 +106,8 @@ private:
     std::vector<event *> signalEvents;
     std::map<int, TransportReceiver*> receivers; // fd -> receiver
     std::map<TransportReceiver*, int> fds; // receiver -> fd
-    std::map<const replication::Configuration *, int> multicastFds;
-    std::map<int, const replication::Configuration *> multicastConfigs;
+    std::map<const transport::Configuration *, int> multicastFds;
+    std::map<int, const transport::Configuration *> multicastConfigs;
     int lastTimerId;
     std::map<int, UDPTransportTimerInfo *> timers;
     uint64_t lastFragMsgId;
@@ -122,13 +122,13 @@ private:
                              const UDPTransportAddress &dst,
                              const Message &m, bool multicast = false);
     UDPTransportAddress
-    LookupAddress(const replication::ReplicaAddress &addr);
+    LookupAddress(const transport::ReplicaAddress &addr);
     UDPTransportAddress
-    LookupAddress(const replication::Configuration &cfg,
+    LookupAddress(const transport::Configuration &cfg,
                   int replicaIdx);
     const UDPTransportAddress *
-    LookupMulticastAddress(const replication::Configuration *cfg);
-    void ListenOnMulticastPort(const replication::Configuration
+    LookupMulticastAddress(const transport::Configuration *cfg);
+    void ListenOnMulticastPort(const transport::Configuration
                                *canonicalConfig);
     void OnReadable(int fd);
     void OnTimer(UDPTransportTimerInfo *info);

replication/common/client.cc

@@ -37,7 +37,7 @@
 
 namespace replication {
     
-Client::Client(const Configuration &config, Transport *transport,
+Client::Client(const transport::Configuration &config, Transport *transport,
                uint64_t clientid)
     : config(config), transport(transport)
 {

replication/common/log.cc

@@ -28,7 +28,7 @@
  *
  **********************************************************************/
 
-#include "replicationcommon/log.h"
+#include "replication/common/log.h"
 #include "replication/common/request.pb.h"
 #include "lib/assert.h"
 

replication/common/replica.cc

@@ -34,7 +34,7 @@
 #include "replication/common/log.h"
 #include "replication/common/replica.h"
 
-#include "replication/lib/message.h"
+#include "lib/message.h"
 
 #include <stdlib.h>
 

replication/vr/tests/vr-test.cc

@@ -53,6 +53,25 @@ using namespace replication;
 using namespace replication::vr;
 using namespace replication::vr::proto;
 
+class VRApp : public AppReplica {
+
+    std::vector<string> *ops;
+    std::vector<string> *unloggedOps;
+
+public:
+    VRApp(std::vector<string> *o, std::vector<string> *u) : ops(o), unloggedOps(u) { }
+    
+    void ReplicaUpcall(Replica *r, opnum_t opnum, const string &req, string &reply) {
+        ops->push_back(req);
+        reply = "reply: " + req;
+    }
+
+    void UnloggedUpcall(Replica *r, const string &req, string &reply) {
+        unloggedOps->push_back(req);
+        reply = "unlreply: " + req;
+    }
+};
+    
 class VRTest : public  ::testing::TestWithParam<int>
 {
 protected:
@@ -77,15 +96,7 @@ protected:
         unloggedOps.resize(config->n);
 
         for (int i = 0; i < config->n; i++) {
-            replicas.push_back(new VRReplica(*config, i, transport, GetParam(),
-                                             [i,this](Replica *r, opnum_t opnum, const string &req, string &reply) {
-                                                 ops[i].push_back(req);
-                                                 reply = "reply: " + req;
-                                             },
-                                   [i,this](Replica *r, const string &req, string &reply) {
-                                                 unloggedOps[i].push_back(req);
-                                                 reply = "unlreply: " + req;
-                                             }));
+            replicas.push_back(new VRReplica(*config, i, transport, GetParam(), new VRApp(&ops[i], &unloggedOps[i])));
         }
 
         client = new VRClient(*config, transport);
@@ -174,7 +185,7 @@ TEST_P(VRTest, Unlogged)
     ClientSendNextUnlogged(1, upcall, timeout);
     transport->Run();
 
-    for (int i = 0; i < ops.size(); i++) {
+    for (unsigned int i = 0; i < ops.size(); i++) {
         EXPECT_EQ(0, ops[i].size());
         EXPECT_EQ((i == 1 ? 1 : 0), unloggedOps[i].size());
     }
@@ -210,7 +221,7 @@ TEST_P(VRTest, UnloggedTimeout)
     ClientSendNextUnlogged(1, upcall, timeout);
     transport->Run();
 
-    for (int i = 0; i < ops.size(); i++) {
+    for (unsigned int i = 0; i < ops.size(); i++) {
         EXPECT_EQ(0, ops[i].size());
         EXPECT_EQ(0, unloggedOps[i].size());
     }