@@ -41,7 +41,7 @@ public:

     conversation (const std::shared_ptr<conversation_ifc> &delegate) :

         delegate_ (delegate) {}

     conversation() : conversation (std::make_shared<conversation_ifc>()

-                                       ) {}

+                                      ) {}

     conversation_result initiate (const pam_request &request)

     {

         return delegate_->initiate (request);

@@ -1,11 +1,24 @@

+/* 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 <string>

 #include <iostream>

 #include "installer.h"

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

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

+{

     installer tool;

     std::string generated_token = tool.install_token();

     std::cout << generated_token << std::endl;

     return 0;

 }

+

@@ -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 GENERATOR_H_

 #define GENERATOR_H_

@@ -6,8 +17,9 @@

 using generator = std::function<std::string()>;

-inline generator make_generator() {

-    return [] {return std::string("234567");};

+inline generator make_generator()

+{

+    return [] {return std::string ("234567");};

 }

 #endif

@@ -1,29 +1,43 @@

+/* 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 <algorithm>

 #include "generator.h"

 #include "test_util.h"

-int six_digits()  {

-   // given

-   generator generator = make_generator();

-

-  // when

-  auto actual = generator();

+int six_digits()

+{

+    // given

+    generator generator = make_generator();

+    // when

+    auto actual = generator();

-  // then

-  check(actual.size() == 6, "size is wrong");

-  check(std::all_of(actual.begin(), actual.end(), [](char c){ return c >= '0' && c <= '9';}), "not just digits");

-  succeed();

+    // then

+    check (actual.size() == 6, "size is wrong");

+    check (std::all_of (actual.begin(), actual.end(), [] (char c) {

+        return c >= '0' && c <= '9';

+    }), "not just digits");

+    succeed();

 }

-

-int run_tests() {

-    test(six_digits);

+int run_tests()

+{

+    test (six_digits);

     succeed();

 }

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

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

+{

     return !run_tests();

 }

@@ -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.

+ */

+

 #include <string>

 #include <vector>

@@ -6,43 +17,50 @@

 #include "sys_unistd.h"

 #include "user.h"

-namespace {

-

-class impl : public installer_ifc {

-    private:

-        tokens tokens_;

-        unistd unistd_;

-        directory directory_;

-        generator generator_;

-    public:

-        impl(const tokens &tokens, const unistd &unistd,

-            const directory &directory, const installer_ifc::generator &generator) :

-            tokens_(tokens), unistd_(unistd), directory_(directory), generator_(generator) {}

-        std::string install_token() const override {

-            const char *c_user_name = unistd_.getlogin();

-            if (c_user_name == nullptr) {

-                return "";

-            }

-

-            std::string user_name = c_user_name;

-

-            auto found_user = directory_.find_user(user_name);

-            if (found_user.empty()) {

-                return "";

-            }

-

-            user user(found_user[0]);

-            std::string token(generator_());

-            tokens_.save(user, token);

-            return token;

+namespace

+{

+

+class impl : public installer_ifc

+{

+private:

+    tokens tokens_;

+    unistd unistd_;

+    directory directory_;

+    generator generator_;

+public:

+    impl (const tokens &tokens, const unistd &unistd,

+          const directory &directory, const installer_ifc::generator &generator) :

+        tokens_ (tokens), unistd_ (unistd), directory_ (directory),

+        generator_ (generator) {}

+    std::string install_token() const override

+    {

+        const char *c_user_name = unistd_.getlogin();

+

+        if (c_user_name == nullptr) {

+            return "";

         }

+

+        std::string user_name = c_user_name;

+

+        auto found_user = directory_.find_user (user_name);

+

+        if (found_user.empty()) {

+            return "";

+        }

+

+        user user (found_user[0]);

+        std::string token (generator_());

+        tokens_.save (user, token);

+        return token;

+    }

 };

 }

-

-installer installer::create(const tokens &tokens, const unistd &unistd,

-        const directory &directory, const installer_ifc::generator &generator) {

-    return installer(std::make_shared<impl>(tokens, unistd, directory, generator));

+installer installer::create (const tokens &tokens, const unistd &unistd,

+                             const directory &directory, const installer_ifc::generator &generator)

+{

+    return installer (std::make_shared<impl> (tokens, unistd, directory,

+                      generator));

 }

@@ -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 INSTALLER_H_

 #define INSTALLER_H_

@@ -9,30 +20,32 @@

 #include "sys_unistd.h"

 #include "user.h"

-

-class installer_ifc {

-    public:

-        using generator = std::function<std::string()>;

-        virtual std::string install_token() const {

-            return "123456";

-        }

+class installer_ifc

+{

+public:

+    using generator = std::function<std::string()>;

+    virtual std::string install_token() const

+    {

+        return "123456";

+    }

 };

-class installer {

-    public:

-        using delegate = std::shared_ptr<installer_ifc>;

-    private:

-        delegate delegate_;

-    public:

-        installer(const delegate &delegate = std::make_shared<installer_ifc>()) : delegate_(delegate) {}

-        std::string install_token() const {

-            return delegate_->install_token();

-        }

-        static installer create(const tokens &tokens, const unistd &unistd,

-            const directory &directory, const installer_ifc::generator &generator);

+class installer

+{

+public:

+    using delegate = std::shared_ptr<installer_ifc>;

+private:

+    delegate delegate_;

+public:

+    installer (const delegate &delegate = std::make_shared<installer_ifc>()) :

+        delegate_ (delegate) {}

+    std::string install_token() const

+    {

+        return delegate_->install_token();

+    }

+    static installer create (const tokens &tokens, const unistd &unistd,

+                             const directory &directory, const installer_ifc::generator &generator);

 };

-

-

-

 #endif

+

@@ -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.

+ */

+

 #include <functional>

 #include <memory>

 #include <string>

@@ -8,118 +19,138 @@

 #include "token.h"

 #include "test_util.h"

-class mock_tokens : public tokens_ifc {

-    public:

-        mutable std::string captured_token;

-        void save (const user &user, const std::string &token) const override {

-            captured_token = token;

-        }

+class mock_tokens : public tokens_ifc

+{

+public:

+    mutable std::string captured_token;

+    void save (const user &user, const std::string &token) const override

+    {

+        captured_token = token;

+    }

 };

-class fake_unistd : public unistd_ifc {

-    private:

-        std::string user_name_;

-    public:

-        fake_unistd(const std::string &user_name) : user_name_(user_name) {}

-        const char *getlogin() const override {

-            return user_name_.c_str();

-        }

+class fake_unistd : public unistd_ifc

+{

+private:

+    std::string user_name_;

+public:

+    fake_unistd (const std::string &user_name) : user_name_ (user_name) {}

+    const char *getlogin() const override

+    {

+        return user_name_.c_str();

+    }

 };

-class fail_unistd : public unistd_ifc {

-    public:

-        const char *getlogin() const override {

-            return nullptr;

-        }

+class fail_unistd : public unistd_ifc

+{

+public:

+    const char *getlogin() const override

+    {

+        return nullptr;

+    }

 };

-class fake_directory : public directory_ifc {

-    private:

-        std::string expected_user_name_;

-    public:

-        fake_directory(const std::string &expected_user_name) : expected_user_name_(expected_user_name) {

-        }

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

-            std::vector<user> rval;

-            if (user_name == expected_user_name_) {

-                rval.push_back(user());

-            }

-            return rval;

+class fake_directory : public directory_ifc

+{

+private:

+    std::string expected_user_name_;

+public:

+    fake_directory (const std::string &expected_user_name) :

+        expected_user_name_ (expected_user_name)

+    {

+    }

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

+    {

+        std::vector<user> rval;

+

+        if (user_name == expected_user_name_) {

+            rval.push_back (user());

         }

+        return rval;

+    }

+

 };

-int installs_token() {

+int installs_token()

+{

     //given

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

-    std::string token("token");

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

+    std::string token ("token");

     auto  test_tokens = std::make_shared<mock_tokens>();

     tokens tokens{test_tokens};

-    unistd unistd(std::make_shared<fake_unistd>(user_name));

-    directory directory(std::make_shared<fake_directory>(user_name));

+    unistd unistd (std::make_shared<fake_unistd> (user_name));

+    directory directory (std::make_shared<fake_directory> (user_name));

     installer_ifc::generator generator = [&] { return token; };

-    installer installer = installer::create (tokens, unistd, directory, generator);

+    installer installer = installer::create (tokens, unistd, directory,

+                          generator);

     //when

     std::string result = installer.install_token();

     //then

-    check(test_tokens->captured_token == token, "installed wrong token");

-    check(result == token, "installer returned wrong token");

+    check (test_tokens->captured_token == token, "installed wrong token");

+    check (result == token, "installer returned wrong token");

     succeed();

 }

-int unistd_does_not_find_user_name() {

+int unistd_does_not_find_user_name()

+{

     //given

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

-    std::string token("token");

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

+    std::string token ("token");

     auto  test_tokens = std::make_shared<mock_tokens>();

     tokens tokens{test_tokens};

-    unistd unistd(std::make_shared<fail_unistd>());

-    directory directory(std::make_shared<fake_directory>(user_name));

+    unistd unistd (std::make_shared<fail_unistd>());

+    directory directory (std::make_shared<fake_directory> (user_name));

     installer_ifc::generator generator = [&] { return token; };

-    installer installer = installer::create (tokens, unistd, directory, generator);

-

+    installer installer = installer::create (tokens, unistd, directory,

+                          generator);

     //when

     auto returned = installer.install_token();

     //then

-    check(test_tokens->captured_token == "", "should not have installed a token");

-    check(returned == "", "did not return empty token");

+    check (test_tokens->captured_token == "",

+           "should not have installed a token");

+    check (returned == "", "did not return empty token");

     succeed();

 }

-int directory_finds_no_user_info() {

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

-    std::string token("token");

+int directory_finds_no_user_info()

+{

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

+    std::string token ("token");

     auto  test_tokens = std::make_shared<mock_tokens>();

     tokens tokens{test_tokens};

-    unistd unistd(std::make_shared<fake_unistd>(user_name));

-    directory directory(std::make_shared<fake_directory>("not the user"));

+    unistd unistd (std::make_shared<fake_unistd> (user_name));

+    directory directory (std::make_shared<fake_directory> ("not the user"));

     installer_ifc::generator generator = [&] { return token; };

-    installer installer = installer::create (tokens, unistd, directory, generator);

+    installer installer = installer::create (tokens, unistd, directory,

+                          generator);

     //when

     auto returned = installer.install_token();

     //then

-    check(test_tokens->captured_token == "", "installed wrong token");

-    check(returned == "", "did not return empty token");

+    check (test_tokens->captured_token == "", "installed wrong token");

+    check (returned == "", "did not return empty token");

     succeed();

 }

-int run_tests() {

-    test(installs_token);

-    test(unistd_does_not_find_user_name);

-    test(directory_finds_no_user_info);

+int run_tests()

+{

+    test (installs_token);

+    test (unistd_does_not_find_user_name);

+    test (directory_finds_no_user_info);

     succeed();

 }

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

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

+{

     return !run_tests();

 }

@@ -1,19 +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 <cstdlib>

 #include <memory>

 #include "sys_stdlib.h"

-namespace {

-    class impl : public stdlib_ifc {

-        public:

-            int rand() const override {

-                return ::rand();

-            }

+namespace

+{

+class impl : public stdlib_ifc

+{

+public:

+    int rand() const override

+    {

+        return ::rand();

+    }

-    };

+};

 }

-stdlib const &stdlib::get() {

+stdlib const &stdlib::get()

+{

     static stdlib singleton {std::make_shared<impl>()};

     return singleton;

 }

+

@@ -1,23 +1,43 @@

+/* 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_CSTDLIB_H_

 #define SYS_CSTDLIB_H_

 #include <memory>

-class stdlib_ifc {

-    public:

-        virtual int rand() const {return 0;}

+class stdlib_ifc

+{

+public:

+    virtual int rand() const

+    {

+        return 0;

+    }

 };

-class stdlib {

-    public:

-        using delegate = std::shared_ptr<stdlib_ifc>;

-    private:

-       delegate delegate_;

-    public:

-       stdlib(delegate delegate = std::make_shared<stdlib_ifc>()) : delegate_(delegate) {}

-      int rand() const { return delegate_->rand(); }

-      static const stdlib& get();

+class stdlib

+{

+public:

+    using delegate = std::shared_ptr<stdlib_ifc>;

+private:

+    delegate delegate_;

+public:

+    stdlib (delegate delegate = std::make_shared<stdlib_ifc>()) : delegate_

+        (delegate) {}

+    int rand() const

+    {

+        return delegate_->rand();

+    }

+    static const stdlib &get();

 };

-

 #endif

+

@@ -24,7 +24,8 @@ public:

     {

         return -1;

     }

-    virtual const char *getlogin() const {

+    virtual const char *getlogin() const

+    {

         return "";

     }

 };

@@ -44,7 +45,8 @@ public:

     {

         return delegate_->sysconf (name);

     }

-    const char *getlogin() const {

+    const char *getlogin() const

+    {

         return delegate_->getlogin();

     }

     static unistd create();