@@ -1,20 +1,35 @@

+/* Copyright (C) CJ Affiliate

+ *

+ * You may use, distribute and modify this code under  the

+ * terms of the  GNU General Public License  version 2  or

+ * later.

+ *

+ * You should have received a copy of the license with this

+ * file. If not, you will find a copy in the "LICENSE" file

+ * at https://github.com/cjdev/dual-control.

+ */

+

 #include "sys_pwd.h"

 #include <pwd.h>

-namespace {

-    class impl : public pwd_ifc {

-        public:

-        int getpwnam_r(const char *user_name, passwd *out, char *buffer,

-                size_t buffer_sz, passwd **result) {

-            return ::getpwnam_r(user_name, out, buffer, buffer_sz, result);

-        }

+namespace

+{

+class impl : public pwd_ifc

+{

+public:

+    int getpwnam_r (const char *user_name, passwd *out, char *buffer,

+                    size_t buffer_sz, passwd **result)

+    {

+        return ::getpwnam_r (user_name, out, buffer, buffer_sz, result);

+    }

-    };

-    static pwd system_pwd(pwd::delegate(new impl));

+};

+static pwd system_pwd (pwd::delegate (new impl));

 }

-pwd pwd::system() {

+pwd pwd::system()

+{

     return system_pwd;

 }

@@ -1,33 +1,49 @@

+/* Copyright (C) CJ Affiliate

+ *

+ * You may use, distribute and modify this code under  the

+ * terms of the  GNU General Public License  version 2  or

+ * later.

+ *

+ * You should have received a copy of the license with this

+ * file. If not, you will find a copy in the "LICENSE" file

+ * at https://github.com/cjdev/dual-control.

+ */

+

 #ifndef _SYS_PWD_H

 #define _SYS_PWD_H

 #include <memory>

 #include <pwd.h>

-class pwd_ifc {

-    public:

-        virtual int getpwnam_r(const char *user_name, passwd *out, char *buffer,

-                size_t buffer_sz, passwd **result) {

-            *result = 0;

-            return 0;

-        };

+class pwd_ifc

+{

+public:

+    virtual int getpwnam_r (const char *user_name, passwd *out, char *buffer,

+                            size_t buffer_sz, passwd **result)

+    {

+        *result = 0;

+        return 0;

+    };

 };

-class pwd : public pwd_ifc {

-    public:

-        typedef std::shared_ptr<pwd_ifc> delegate;

-

-    private:

-        delegate delegate_;

-

-    public:

-        pwd(const delegate delegate) : delegate_(delegate) {}

-        pwd() : delegate_(delegate(new pwd_ifc)) {}

-        int getpwnam_r(const char *user_name, passwd *out, char *buffer,

-                size_t buffer_sz, passwd **result) {

-            return delegate_-> getpwnam_r(user_name, out, buffer, buffer_sz, result);

-        }

-        static pwd system();

+class pwd : public pwd_ifc

+{

+public:

+    typedef std::shared_ptr<pwd_ifc> delegate;

+

+private:

+    delegate delegate_;

+

+public:

+    pwd (const delegate delegate) : delegate_ (delegate) {}

+    pwd() : delegate_ (delegate (new pwd_ifc)) {}

+    int getpwnam_r (const char *user_name, passwd *out, char *buffer,

+                    size_t buffer_sz, passwd **result)

+    {

+        return delegate_-> getpwnam_r (user_name, out, buffer, buffer_sz, result);

+    }

+    static pwd system();

 };

 #endif

+

@@ -1,16 +1,32 @@

+/* Copyright (C) CJ Affiliate

+ *

+ * You may use, distribute and modify this code under  the

+ * terms of the  GNU General Public License  version 2  or

+ * later.

+ *

+ * You should have received a copy of the license with this

+ * file. If not, you will find a copy in the "LICENSE" file

+ * at https://github.com/cjdev/dual-control.

+ */

+

 #include "sys_unistd.h"

 #include <unistd.h>

-namespace {

-    class impl : public unistd_ifc {

-        public:

-            long int sysconf(int name) {

-                return ::sysconf(name);

-            }

-    };

-    static unistd sys_unistd(unistd::delegate(new impl));

+namespace

+{

+class impl : public unistd_ifc

+{

+public:

+    long int sysconf (int name)

+    {

+        return ::sysconf (name);

+    }

+};

+static unistd sys_unistd (unistd::delegate (new impl));

 }

-unistd unistd::system() {

+unistd unistd::system()

+{

     return sys_unistd;

 }

+

@@ -1,3 +1,14 @@

+/* Copyright (C) CJ Affiliate

+ *

+ * You may use, distribute and modify this code under  the

+ * terms of the  GNU General Public License  version 2  or

+ * later.

+ *

+ * You should have received a copy of the license with this

+ * file. If not, you will find a copy in the "LICENSE" file

+ * at https://github.com/cjdev/dual-control.

+ */

+

 #ifndef _SYS_UNISTD_H_

 #define _SYS_UNISTD_H_

@@ -5,27 +16,32 @@

 #include <unistd.h>

-class unistd_ifc {

-    public:

-        virtual long int sysconf(int name) { return -1; }

+class unistd_ifc

+{

+public:

+    virtual long int sysconf (int name)

+    {

+        return -1;

+    }

 };

-class unistd : public unistd_ifc {

-    public:

-        typedef std::shared_ptr<unistd_ifc> delegate;

-

-    private:

-        delegate delegate_;

-

-    public:

-        unistd(delegate delegate): delegate_(delegate) {}

-        unistd() : delegate_(delegate(new unistd_ifc)) {}

-        long int sysconf(int name) {

-            return delegate_->sysconf(name);

-        }

-        static unistd system();

+class unistd : public unistd_ifc

+{

+public:

+    typedef std::shared_ptr<unistd_ifc> delegate;

+

+private:

+    delegate delegate_;

+

+public:

+    unistd (delegate delegate): delegate_ (delegate) {}

+    unistd() : delegate_ (delegate (new unistd_ifc)) {}

+    long int sysconf (int name)

+    {

+        return delegate_->sysconf (name);

+    }

+    static unistd system();

 };

-

-

 #endif

+

@@ -12,35 +12,40 @@

 #include <memory>

 #include <vector>

-

 #include "user.h"

 #include "sys_unistd.h"

 #include "sys_pwd.h"

-namespace {

-    class directory_impl : public directory_ifc {

-        private:

-            unistd unistd_;

-            pwd pwd_;

-        public:

-          directory_impl(unistd &unistd, pwd &pwd) : unistd_(unistd), pwd_(pwd) {}

-          std::vector<user> find_user (const std::string &user_name) {

-              std::vector<char> buffer (unistd_.sysconf (_SC_GETPW_R_SIZE_MAX));

-              passwd sys_passwd;

-              passwd *found_passwd(0);

-              int result = pwd_.getpwnam_r(user_name.c_str(), &sys_passwd,

-                      buffer.data(), buffer.size(), &found_passwd);

-              std::vector<user> return_value;

-              if (!result && found_passwd) {

-                  return_value.push_back(user());

-              }

-              return return_value;

-          }

-    };

+namespace

+{

+class directory_impl : public directory_ifc

+{

+private:

+    unistd unistd_;

+    pwd pwd_;

+public:

+    directory_impl (unistd &unistd, pwd &pwd) : unistd_ (unistd), pwd_ (pwd) {}

+    std::vector<user> find_user (const std::string &user_name)

+    {

+        std::vector<char> buffer (unistd_.sysconf (_SC_GETPW_R_SIZE_MAX));

+        passwd sys_passwd;

+        passwd *found_passwd (0);

+        int result = pwd_.getpwnam_r (user_name.c_str(), &sys_passwd,

+                                      buffer.data(), buffer.size(), &found_passwd);

+        std::vector<user> return_value;

+

+        if (!result && found_passwd) {

+            return_value.push_back (user());

+        }

+

+        return return_value;

+    }

+};

 }

-directory directory::create(unistd &unistd, pwd &pwd) {

-    return directory(delegate(new directory_impl(unistd, pwd)));

+directory directory::create (unistd &unistd, pwd &pwd)

+{

+    return directory (delegate (new directory_impl (unistd, pwd)));

 }

 /*

@@ -45,20 +45,20 @@ public:

 class directory : public directory_ifc

 {

-    public:

-        typedef std::shared_ptr<directory_ifc> delegate;

-    private:

-        delegate delegate_;

-    public:

+public:

+    typedef std::shared_ptr<directory_ifc> delegate;

+private:

+    delegate delegate_;

+public:

     directory (delegate delegate) : delegate_

         (delegate) {}

-    directory() : directory(delegate(new directory_ifc)) {}

+    directory() : directory (delegate (new directory_ifc)) {}

     std::vector<user> find_user (const std::string &user_name)

     {

         return delegate_->find_user (user_name);

     }

-    static directory create(unistd &unistd, pwd &pwd);

+    static directory create (unistd &unistd, pwd &pwd);

 };

 #endif

@@ -14,137 +14,158 @@

 #include "sys_pwd.h"

 #include "sys_unistd.h"

-class fake_pwd : public pwd_ifc {

-    private:

-        std::string expected_user_name_;

-    public:

-        fake_pwd(const std::string expected_user_name) : expected_user_name_(expected_user_name) {}

-        int getpwnam_r(const char *user_name, passwd *out, char *buffer,

-                       size_t buffer_sz, passwd **result) {

-            if (expected_user_name_ == user_name)  {

-                *result = out;

-            } else {

+class fake_pwd : public pwd_ifc

+{

+private:

+    std::string expected_user_name_;

+public:

+    fake_pwd (const std::string expected_user_name) : expected_user_name_

+        (expected_user_name) {}

+    int getpwnam_r (const char *user_name, passwd *out, char *buffer,

+                    size_t buffer_sz, passwd **result)

+    {

+        if (expected_user_name_ == user_name)  {

+            *result = out;

+        } else {

             *result = 0;

-            }

-            return 0;

         }

+

+        return 0;

+    }

 };

-class match_buffer_pwd : public pwd_ifc {

-    private:

-        long int expected_buffer_sz_;

-    public:

-        match_buffer_pwd(long int buffer_sz) : expected_buffer_sz_(buffer_sz) {}

-        int getpwnam_r(const char *user_name, passwd *out, char *buffer,

-                       size_t buffer_sz, passwd **result) {

-

-            if (expected_buffer_sz_ == buffer_sz && buffer != 0) {

-                *result = out;

-            } else {

+class match_buffer_pwd : public pwd_ifc

+{

+private:

+    long int expected_buffer_sz_;

+public:

+    match_buffer_pwd (long int buffer_sz) : expected_buffer_sz_ (buffer_sz) {}

+    int getpwnam_r (const char *user_name, passwd *out, char *buffer,

+                    size_t buffer_sz, passwd **result)

+    {

+

+        if (expected_buffer_sz_ == buffer_sz && buffer != 0) {

+            *result = out;

+        } else {

             *result = 0;

-            }

-            return 0;

         }

+

+        return 0;

+    }

 };

-class stub_pwnam_err_pwd : public pwd_ifc {

-    public:

-        int getpwnam_r(const char *user_name, passwd *out, char *buffer,

-                       size_t buffer_sz, passwd **result) {

-            *result = out;

-            return 3;

-        }

+class stub_pwnam_err_pwd : public pwd_ifc

+{

+public:

+    int getpwnam_r (const char *user_name, passwd *out, char *buffer,

+                    size_t buffer_sz, passwd **result)

+    {

+        *result = out;

+        return 3;

+    }

 };

-class fake_unistd : public unistd_ifc {

-    private:

-        int expected_name_;

-        long int return_value_;

-    public:

-        fake_unistd(int expected_name, long int return_value = 0)

-            : expected_name_(expected_name),

-              return_value_(return_value) {}

-        long int sysconf(int name) {

-            if (name == expected_name_) {

+class fake_unistd : public unistd_ifc

+{

+private:

+    int expected_name_;

+    long int return_value_;

+public:

+    fake_unistd (int expected_name, long int return_value = 0)

+        : expected_name_ (expected_name),

+          return_value_ (return_value) {}

+    long int sysconf (int name)

+    {

+        if (name == expected_name_) {

             return return_value_;

-            }

-            return -1;

         }

+

+        return -1;

+    }

 };

-int find_user_happy() {

+int find_user_happy()

+{

     //given

-    std::string user_name("user");

-    pwd test_pwd(pwd::delegate(new fake_pwd(user_name)));

-    unistd test_unistd(unistd::delegate(new fake_unistd(_SC_GETPW_R_SIZE_MAX)));

-    directory directory(directory::create(test_unistd, test_pwd));

+    std::string user_name ("user");

+    pwd test_pwd (pwd::delegate (new fake_pwd (user_name)));

+    unistd test_unistd (unistd::delegate (new fake_unistd (

+            _SC_GETPW_R_SIZE_MAX)));

+    directory directory (directory::create (test_unistd, test_pwd));

     //when

-    std::vector<user> results = directory.find_user(user_name);

+    std::vector<user> results = directory.find_user (user_name);

     //then

-    check(!results.empty(), "user should have been found");

+    check (!results.empty(), "user should have been found");

     succeed();

 }

-int user_not_found() {

+int user_not_found()

+{

     //given

-    pwd test_pwd(pwd::delegate(new fake_pwd("user")));

-    unistd test_unistd(unistd::delegate(new fake_unistd(_SC_GETPW_R_SIZE_MAX)));

-    directory directory(directory::create(test_unistd, test_pwd));

+    pwd test_pwd (pwd::delegate (new fake_pwd ("user")));

+    unistd test_unistd (unistd::delegate (new fake_unistd (

+            _SC_GETPW_R_SIZE_MAX)));

+    directory directory (directory::create (test_unistd, test_pwd));

     //when

-    std::vector<user> results = directory.find_user("not_user");

+    std::vector<user> results = directory.find_user ("not_user");

     //then

-    check(results.empty(), "user should not have been found");

+    check (results.empty(), "user should not have been found");

     succeed();

 }

-int find_user_passes_buffer_and_size()  {

+int find_user_passes_buffer_and_size()

+{

     //given

     long int buffer_sz = 5976;

-    unistd test_unistd(unistd::delegate(new fake_unistd(_SC_GETPW_R_SIZE_MAX, buffer_sz)));

-    pwd match_pwd(pwd::delegate(new match_buffer_pwd(buffer_sz)));

-    directory directory(directory::create(test_unistd, match_pwd));

+    unistd test_unistd (unistd::delegate (new fake_unistd (_SC_GETPW_R_SIZE_MAX,

+                                          buffer_sz)));

+    pwd match_pwd (pwd::delegate (new match_buffer_pwd (buffer_sz)));

+    directory directory (directory::create (test_unistd, match_pwd));

     //when

-    std::vector<user> results = directory.find_user("does_not_matter");

-

+    std::vector<user> results = directory.find_user ("does_not_matter");

     // then

-    check(!results.empty(), "match failed");

+    check (!results.empty(), "match failed");

     succeed();

 }

-int find_user_fails_on_pwnam_r_error_and_result_ok()  {

+int find_user_fails_on_pwnam_r_error_and_result_ok()

+{

     //given

-    unistd test_unistd(unistd::delegate(new fake_unistd(_SC_GETPW_R_SIZE_MAX)));

-    pwd stub_pwd(pwd::delegate(new stub_pwnam_err_pwd));

-    directory directory(directory::create(test_unistd, stub_pwd));

+    unistd test_unistd (unistd::delegate (new fake_unistd (

+            _SC_GETPW_R_SIZE_MAX)));

+    pwd stub_pwd (pwd::delegate (new stub_pwnam_err_pwd));

+    directory directory (directory::create (test_unistd, stub_pwd));

     //when

-    std::vector<user> results = directory.find_user("does_not_matter");

+    std::vector<user> results = directory.find_user ("does_not_matter");

     // then

-    check(results.empty(), "did not check return");

+    check (results.empty(), "did not check return");

     succeed();

 }

 RESET_VARS_START

 RESET_VARS_END

-int run_tests() {

-    test(find_user_happy);

-    test(user_not_found);

-    test(find_user_passes_buffer_and_size);

-    test(find_user_fails_on_pwnam_r_error_and_result_ok);

+int run_tests()

+{

+    test (find_user_happy);

+    test (user_not_found);

+    test (find_user_passes_buffer_and_size);

+    test (find_user_fails_on_pwnam_r_error_and_result_ok);

     succeed();

 }

-int main(int argc, char **argv) {

+int main (int argc, char **argv)

+{

     return !run_tests();

 }