Développement multiplateforme mobile et Web avec C ++ expliqué

Partie 3: Tests unitaires et autres goodies

Il semble que les tests unitaires soient devenus une religion ces jours-ci. Les gens oublient souvent qu’écrire des tests, c’est écrire du code: cela augmente la surface des bogues et le temps de développement. Je ne suis pas un extrémiste des tests unitaires mais dans notre cas, ils sont utiles.

class Xptuto : public ::testing::Test {
protected:
void SetUp() override {
stubHttp = std::make_shared();
promise = std::make_sharedvoid>>();
future = promise->get_future();
}
std::shared_ptr stubHttp;
std::shared_ptrvoid>> promise;
std::future<void> future;
};
TEST_F(Xptuto, GetUsersEmptyTest) {
auto instance = ::xptuto::Xptuto::make_instance(stubHttp);
stubHttp->path = "/responses/users_aosp.json";
auto p = promise;
instance->get_users(std::make_shared(
[p](const std::vector &users) {
EXPECT_FALSE(users.empty());
p->set_value();
}, [p](const std::string &) {
FAIL();
}
));
if (future.wait_for(1s) != std::future_status::ready) {
FAIL();
}
}
...

void HttpClientStub::get(const std::string &url, const std::shared_ptr &callback) {
auto p = path.value();
std::thread t([p](const std::shared_ptr &cb) {
auto stream = std::ifstream(std::string(TEST_PATH) + p);
auto response = std::string((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());
cb->on_response({response, 200});
}, callback);
t.detach();
}

get_users_cb = interface +j +c {
on_success(users : list);
on_error(error: string);
}http_client = interface +j +c {
get(url: string, callback: http_callback);
}...

class GetUsersCbImpl : public xptuto::GetUsersCb {
public:
GetUsersCbImpl(
std::function<void(const std::vector &)> successFn,
std::function<void(const std::string &)> failureFn);






void on_success(const std::vector &users) override;
...
private:
const std::function<void(const std::vector &)> successFn;
...
};

instance->get_users(std::make_shared(
[p](const std::vector &users) {
EXPECT_FALSE(users.empty());
p->set_value();
}, [p](const std::string &) {
FAIL();
}
));

namespace nlohmann {
template<>
struct adl_serializer {
static User from_json(const json &j) {
return {
j["login"].get(), 
j["id"].get(),
j["avatar_url"].get(),
...
}
...
};
};// and you get the user:User user = nlohmann::json::parse(json_string);

Exécutez les tests

Utilisez un IDE, vous irez beaucoup plus vite, vous pouvez exécuter toute la suite ou un test à la fois et vous pouvez également les déboguer.

ccache est un cache pour les compilateurs C, c’est un outil sérieux développé par SAMBA utilisé par la plupart des grands projets comme le noyau Linux et le projet Open Source Android. Il stockera les objets compilés afin que vous n’ayez pas à les recompiler s’ils sont inchangés. Cela fonctionne beaucoup mieux que le dossier de construction XCode que vous devez supprimer en permanence car les choses cessent de fonctionner tout d’un coup.

find_program(CCACHE_FOUND ccache)
if (CCACHE_FOUND)
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_FOUND})
set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE_FOUND})
endif (CCACHE_FOUND)

#!/bin/sh
if [ -x "$(command -v ccache)" ]; then
exec ccache clang++ "$@"
else
exec clang++ "$@"
fi