Add a test for NatController.

[android-x86/system-netd.git] / server / IptablesBaseTest.cpp

diff --git a/server/IptablesBaseTest.cpp b/server/IptablesBaseTest.cpp
index 3b96b81..b52ff9b 100644 (file)
--- a/server/IptablesBaseTest.cpp
+++ b/server/IptablesBaseTest.cpp
@@ -16,14 +16,20 @@
  * IptablesBaseTest.cpp - utility class for tests that use iptables
  */
 
+#include <deque>
 #include <string>
 #include <vector>
 
 #include <gtest/gtest.h>
 
+#include <android-base/stringprintf.h>
+
 #include "IptablesBaseTest.h"
 #include "NetdConstants.h"
 
+#define LOG_TAG "IptablesBaseTest"
+#include <cutils/log.h>
+
 IptablesBaseTest::IptablesBaseTest() {
     sCmds.clear();
     sRestoreCmds.clear();
@@ -32,11 +38,14 @@ IptablesBaseTest::IptablesBaseTest() {
 int IptablesBaseTest::fake_android_fork_exec(int argc, char* argv[], int *status, bool, bool) {
     std::string cmd = argv[0];
     for (int i = 1; i < argc; i++) {
+        if (argv[i] == NULL) break;  // NatController likes to pass in invalid argc values.
         cmd += " ";
         cmd += argv[i];
     }
     sCmds.push_back(cmd);
-    *status = 0;
+    if (status) {
+        *status = 0;
+    }
     return 0;
 }
 
@@ -63,20 +72,37 @@ int IptablesBaseTest::fakeExecIptables(IptablesTarget target, ...) {
     return 0;
 }
 
+FILE *IptablesBaseTest::fake_popen(const char * /* cmd */, const char *type) {
+    if (sPopenContents.empty() || strcmp(type, "r") != 0) {
+        return NULL;
+    }
+
+    std::string realCmd = android::base::StringPrintf("echo '%s'", sPopenContents.front().c_str());
+    sPopenContents.pop_front();
+    return popen(realCmd.c_str(), "r");
+}
+
 int IptablesBaseTest::fakeExecIptablesRestore(IptablesTarget target, const std::string& commands) {
-    EXPECT_EQ(V4V6, target);
-    sRestoreCmds.push_back(commands);
+    sRestoreCmds.push_back({ target, commands });
     return 0;
 }
 
 int IptablesBaseTest::expectIptablesCommand(IptablesTarget target, int pos,
                                             const std::string& cmd) {
+
+    if ((unsigned) pos >= sCmds.size()) {
+        ADD_FAILURE() << "Expected too many iptables commands, want command "
+               << pos + 1 << "/" << sCmds.size();
+        return -1;
+    }
+
     if (target == V4 || target == V4V6) {
         EXPECT_EQ("/system/bin/iptables -w " + cmd, sCmds[pos++]);
     }
     if (target == V6 || target == V4V6) {
         EXPECT_EQ("/system/bin/ip6tables -w " + cmd, sCmds[pos++]);
     }
+
     return target == V4V6 ? 2 : 1;
 }
 
@@ -93,18 +119,44 @@ void IptablesBaseTest::expectIptablesCommands(const ExpectedIptablesCommands& ex
     for (size_t i = 0; i < expectedCmds.size(); i ++) {
         auto target = expectedCmds[i].first;
         auto cmd = expectedCmds[i].second;
-        pos += expectIptablesCommand(target, pos, cmd);
+        int numConsumed = expectIptablesCommand(target, pos, cmd);
+        if (numConsumed < 0) {
+            // Read past the end of the array.
+            break;
+        }
+        pos += numConsumed;
     }
 
     EXPECT_EQ(pos, sCmds.size());
     sCmds.clear();
 }
 
+void IptablesBaseTest::expectIptablesCommands(
+        const std::vector<ExpectedIptablesCommands>& snippets) {
+    ExpectedIptablesCommands expected;
+    for (const auto& snippet: snippets) {
+        expected.insert(expected.end(), snippet.begin(), snippet.end());
+    }
+    expectIptablesCommands(expected);
+}
+
 void IptablesBaseTest::expectIptablesRestoreCommands(const std::vector<std::string>& expectedCmds) {
+    ExpectedIptablesCommands expected;
+    for (auto cmd : expectedCmds) {
+        expected.push_back({ V4V6, cmd });
+    }
+    expectIptablesRestoreCommands(expected);
+}
+
+void IptablesBaseTest::expectIptablesRestoreCommands(const ExpectedIptablesCommands& expectedCmds) {
     EXPECT_EQ(expectedCmds.size(), sRestoreCmds.size());
-    EXPECT_EQ(expectedCmds, sRestoreCmds);
+    for (size_t i = 0; i < expectedCmds.size(); i++) {
+        EXPECT_EQ(expectedCmds[i], sRestoreCmds[i]) <<
+            "iptables-restore command " << i << " differs";
+    }
     sRestoreCmds.clear();
 }
 
 std::vector<std::string> IptablesBaseTest::sCmds = {};
-std::vector<std::string> IptablesBaseTest::sRestoreCmds = {};
+IptablesBaseTest::ExpectedIptablesCommands IptablesBaseTest::sRestoreCmds = {};
+std::deque<std::string> IptablesBaseTest::sPopenContents = {};