Ptr<SocketFactory> rxSocketFactory = rxNode->GetObject<UdpSocketFactory> ();

  Ptr<SocketFactory> udpRxSocketFactory = rxNode->GetObject<UdpSocketFactory> ();

  Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket ();

  Ptr<Socket> udpRxSocket = udpRxSocketFactory->CreateSocket ();

  NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (InetSocketAddress (Ipv4Address ("10.0.0.2"), 1234)), 0, "trivial");

  NS_TEST_EXPECT_MSG_EQ (udpRxSocket->Bind (InetSocketAddress (Ipv4Address ("10.0.0.2"), 1234)), 0, "trivial");

  rxSocket->SetRecvCallback (MakeCallback (&Ipv4ForwardingTest::ReceivePkt, this));

  udpRxSocket->SetRecvCallback (MakeCallback (&Ipv4ForwardingTest::ReceivePkt, this));

  Ptr<SocketFactory> txSocketFactory = txNode->GetObject<UdpSocketFactory> ();

  Ptr<SocketFactory> udpTxSocketFactory = txNode->GetObject<UdpSocketFactory> ();

  Ptr<Socket> txSocket = txSocketFactory->CreateSocket ();

  Ptr<Socket> udpTxSocket = udpTxSocketFactory->CreateSocket ();

  txSocket->SetAllowBroadcast (true);

  udpTxSocket->SetAllowBroadcast (true);

  SendData (txSocket, "10.0.0.2");

  SendData (udpTxSocket, "10.0.0.2");

  SendData (txSocket, "10.0.0.2");

  SendData (udpTxSocket, "10.0.0.2");

  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 0, "IPv4 Forwarding off");

  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket, 0, "IPv4 Forwarding off; no received packet");

  Simulator::Destroy ();

}

class Ipv4BindToNetDeviceTest : public TestCase

{

  Ptr<Packet> m_receivedPacket;

  void DoSendData (Ptr<Socket> socket, std::string to, int expectedReturnValue);

  void SendData (Ptr<Socket> socket, std::string to, int expectedReturnValue);

  //, std::string to, int expectedReturnValue

  void OnConnection (Ptr<Socket> socket

//                     , const ns3::Address&

                     );

public:

  virtual void DoRun (void);

  Ipv4BindToNetDeviceTest ();

  void ReceivePkt (Ptr<Socket> socket);

};

Ipv4BindToNetDeviceTest::Ipv4BindToNetDeviceTest ()

  : TestCase ("Test that Socket::BindToNetDevice () works")

{

}

void Ipv4BindToNetDeviceTest::ReceivePkt (Ptr<Socket> socket)

{

  NS_LOG_DEBUG ("Recv cb");

  uint32_t availableData;

  availableData = socket->GetRxAvailable ();

  m_receivedPacket = socket->Recv (std::numeric_limits<uint32_t>::max (), 0);

  NS_ASSERT (availableData == m_receivedPacket->GetSize ());

}

void

Ipv4BindToNetDeviceTest::DoSendData (Ptr<Socket> socket, std::string to, int expectedReturnValue)

{

  Address realTo = InetSocketAddress (Ipv4Address (to.c_str ()), 1234);

  NS_TEST_EXPECT_MSG_EQ (socket->SendTo (Create<Packet> (123), 0, realTo),

                         expectedReturnValue, "SendTo failure");

}

void

Ipv4BindToNetDeviceTest::SendData (Ptr<Socket> socket, std::string to, int expectedReturnValue)

{

  Simulator::ScheduleWithContext (socket->GetNode ()->GetId (), Seconds (0),

                                  &Ipv4BindToNetDeviceTest::DoSendData, this, socket, to, expectedReturnValue);

}

void

Ipv4BindToNetDeviceTest::OnConnection (Ptr<Socket> socket

//                                       , const ns3::Address&

                                       )

{

    NS_LOG_DEBUG ("Send connection");

    int ret = socket->Send(Create<Packet> (123));

    NS_TEST_EXPECT_MSG_EQ ( ret, 0, "Could not send packet");

}

void

Ipv4BindToNetDeviceTest::DoRun (void)

{

  /** Create topology

  ________________________________________

  |      txNode                           |

  | txDev1 (10.0.0.1) | txDev2 (11.0.0.1) |

  |___________________|___________________|

          |                    |

          |                    |

          |                    |

          |                    |

  ________________________________________

  |      rxNode                           |

  | rxDev1 (10.0.0.2) | rxDev2 (11.0.0.2) |

  |___________________|___________________|

  **/

  // Receiver Node

  Ptr<Node> rxNode = CreateObject<Node> ();

  AddInternetStack (rxNode);

  Ptr<SimpleNetDevice> rxDev1;

  Ptr<SimpleNetDevice> rxDev2;

  { // first interface

    rxDev1 = CreateObject<SimpleNetDevice> ();

    rxDev1->SetAddress (Mac48Address::ConvertFrom (Mac48Address::Allocate ()));

    rxNode->AddDevice (rxDev1);

    Ptr<Ipv4> ipv4 = rxNode->GetObject<Ipv4> ();

    uint32_t netdev_idx = ipv4->AddInterface (rxDev1);

    Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.0.2"), Ipv4Mask (0xffff0000U));

    ipv4->AddAddress (netdev_idx, ipv4Addr);

    ipv4->SetUp (netdev_idx);

  }

  { // second interface

    rxDev2 = CreateObject<SimpleNetDevice> ();

    rxDev2->SetAddress (Mac48Address::ConvertFrom (Mac48Address::Allocate ()));

    rxNode->AddDevice (rxDev2);

    Ptr<Ipv4> ipv4 = rxNode->GetObject<Ipv4> ();

    uint32_t netdev_idx = ipv4->AddInterface (rxDev2);

    Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("11.0.0.2"), Ipv4Mask (0xffff0000U));

    ipv4->AddAddress (netdev_idx, ipv4Addr);

    ipv4->SetUp (netdev_idx);

  }

  // Sender Node

  Ptr<Node> txNode = CreateObject<Node> ();

  AddInternetStack (txNode);

  Ptr<SimpleNetDevice> txDev1;

  Ptr<SimpleNetDevice> txDev2;

  {

    // first interface

    txDev1 = CreateObject<SimpleNetDevice> ();

    txDev1->SetAddress (Mac48Address::ConvertFrom (Mac48Address::Allocate ()));

    txNode->AddDevice (txDev1);

    Ptr<Ipv4> ipv4 = txNode->GetObject<Ipv4> ();

    uint32_t netdev_idx = ipv4->AddInterface (txDev1);

    Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.0.1"), Ipv4Mask (0xffff0000U));

    ipv4->AddAddress (netdev_idx, ipv4Addr);

    ipv4->SetUp (netdev_idx);

  }

  {

    // second interface

    txDev2 = CreateObject<SimpleNetDevice> ();

    txDev2->SetAddress (Mac48Address::ConvertFrom (Mac48Address::Allocate ()));

    txNode->AddDevice (txDev2);

    Ptr<Ipv4> ipv4 = txNode->GetObject<Ipv4> ();

    uint32_t netdev_idx = ipv4->AddInterface (txDev2);

    Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("11.0.0.1"), Ipv4Mask (0xffff0000U));

    ipv4->AddAddress (netdev_idx, ipv4Addr);

    ipv4->SetUp (netdev_idx);

  }

  // link the two nodes

  Ptr<SimpleChannel> channel1 = CreateObject<SimpleChannel> ();

  rxDev1->SetChannel (channel1);

  txDev1->SetChannel (channel1);

  Ptr<SimpleChannel> channel2 = CreateObject<SimpleChannel> ();

  rxDev2->SetChannel (channel2);

  txDev2->SetChannel (channel2);

  // Create the UDP sockets

  Ptr<SocketFactory> udpRxSocketFactory = rxNode->GetObject<UdpSocketFactory> ();

  Ptr<Socket> udpRxSocket = udpRxSocketFactory->CreateSocket ();

  NS_TEST_EXPECT_MSG_EQ (udpRxSocket->Bind (InetSocketAddress (Ipv4Address ("10.0.0.2"), 1234)), 0, "trivial");

  // Must call BindToNetDevice() after Bind()

  udpRxSocket->SetRecvCallback (MakeCallback (&Ipv4BindToNetDeviceTest::ReceivePkt, this));

  Ptr<SocketFactory> udpTxSocketFactory = txNode->GetObject<UdpSocketFactory> ();

  Ptr<Socket> udpTxSocket = udpTxSocketFactory->CreateSocket ();

  udpTxSocket->SetAllowBroadcast (true);

  // Create the TCP sockets

  Ptr<SocketFactory> tcpRxSocketFactory = rxNode->GetObject<TcpSocketFactory> ();

  Ptr<Socket> tcpRxSocket = tcpRxSocketFactory->CreateSocket ();

  NS_TEST_EXPECT_MSG_EQ (tcpRxSocket->Bind (InetSocketAddress (Ipv4Address ("10.0.0.2"), 1234)), 0, "trivial");

  // Must call BindToNetDevice() after Bind()

  tcpRxSocket->SetRecvCallback (MakeCallback (&Ipv4BindToNetDeviceTest::ReceivePkt, this));

  Ptr<SocketFactory> tcpTxSocketFactory = txNode->GetObject<UdpSocketFactory> ();

//  Ptr<TcpSocket> tcpTxSocket = DynamicCast<TcpSocket>(tcpTxSocketFactory->CreateSocket () );

  Ptr<Socket> tcpTxSocket = tcpTxSocketFactory->CreateSocket ();

//  tcpTxSocket->SetAllowBroadcast (true);

  // ------ Now the UDP tests ------------

  // Test that data is successful when RxNode binds to rxDev1 and TxNode binds

  // to txDev1

  NS_LOG_DEBUG ("Bind test case 1");

  udpRxSocket->BindToNetDevice (rxDev1);

  udpTxSocket->BindToNetDevice (txDev1);

  SendData (udpTxSocket, "10.0.0.2", 123);  // 123 is the expected Send() return value

  Simulator::Run ();

  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 123, "Correctly bound NetDevices");

  m_receivedPacket = 0;

  // All three other bind combinations should fail 

  NS_LOG_DEBUG ("Bind test case 2");

  udpTxSocket = udpTxSocketFactory->CreateSocket ();

  udpRxSocket->BindToNetDevice (rxDev1);

  udpTxSocket->BindToNetDevice (txDev2);

  SendData (udpTxSocket, "10.0.0.2", -1);

  Simulator::Run ();

  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket, 0, "No received packet");

  NS_LOG_DEBUG ("Bind test case 3");

  udpTxSocket = udpTxSocketFactory->CreateSocket ();

  udpRxSocket->BindToNetDevice (rxDev2);

  udpTxSocket->BindToNetDevice (txDev2);

  SendData (udpTxSocket, "10.0.0.2", -1);

  Simulator::Run ();

  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket, 0, "No received packet");

  NS_LOG_DEBUG ("Bind test case 4");

  udpTxSocket = udpTxSocketFactory->CreateSocket ();

  udpRxSocket->BindToNetDevice (rxDev2);

  udpTxSocket->BindToNetDevice (txDev1);

  SendData (udpTxSocket, "10.0.0.2", 123);

  Simulator::Run ();

  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket, 0, "No received packet");

  // ------ Now the TCP tests ------------

  // Test that data is successful when RxNode binds to rxDev1 and TxNode binds

  // to txDev1

  NS_LOG_DEBUG ("Bind test case 1");

  InetSocketAddress serverAddr ("11.0.0.2", 1234 );

  InetSocketAddress clientAddr ("11.0.0.1", 4321 );

//  tcpRxSocket->BindToNetDevice (rxDev1);

//  tcpTxSocket->BindToNetDevice (txDev1);

  tcpTxSocket->Bind( clientAddr );

//  tcpRxSocket->SetAcceptCallback( MakeNullCallback<bool, Ptr<Socket>, const ns3::Address& > (),

//                                 MakeCallback(&Ipv4BindToNetDeviceTest::OnConnection, this) );

  tcpTxSocket->SetConnectCallback ( MakeCallback(&Ipv4BindToNetDeviceTest::OnConnection, this),

                                   MakeNullCallback<void, Ptr<Socket> > ()

                                  );

  tcpTxSocket->Connect( serverAddr );

  //! Make sure packet can only travel through channel2

  channel1->BlackList(txDev1, rxDev1);

//  SendData (tcpTxSocket, "10.0.0.2", 123);  // 123 is the expected Send() return value

  Simulator::Run ();

  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 123, "Correctly bound NetDevices");

  m_receivedPacket = 0;

  // All three other bind combinations should fail 

//  NS_LOG_DEBUG ("Bind test case 2");

//  tcpTxSocket = tcpTxSocketFactory->CreateSocket ();

//  tcpRxSocket->BindToNetDevice (rxDev1);

//  tcpTxSocket->BindToNetDevice (txDev2);

//  SendData (tcpTxSocket, "10.0.0.2", -1);

//  Simulator::Run ();

//  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket, 0, "No received packet");

//

//  NS_LOG_DEBUG ("Bind test case 3");

//  tcpTxSocket = tcpTxSocketFactory->CreateSocket ();

//  tcpRxSocket->BindToNetDevice (rxDev2);

//  tcpTxSocket->BindToNetDevice (txDev2);

//  SendData (tcpTxSocket, "10.0.0.2", -1);

//  Simulator::Run ();

//  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket, 0, "No received packet");

//

//  NS_LOG_DEBUG ("Bind test case 4");

//  tcpTxSocket = tcpTxSocketFactory->CreateSocket ();

//  tcpRxSocket->BindToNetDevice (rxDev2);

//  tcpTxSocket->BindToNetDevice (txDev1);

//  SendData (tcpTxSocket, "10.0.0.2", 123);

//  Simulator::Run ();

//  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket, 0, "No received packet");