simplersble 0.10.4-dev17

The all-in-one Bluetooth library that makes it easy to add wireless connectivity to your projects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

#include <gtest/gtest.h>

#include <simpledbus/advanced/Proxy.h>
#include <simpledbus/advanced/InterfaceRegistry.h>

using namespace SimpleDBus;

const AutoRegisterInterface<Interface> registry_i1{
    "i.1",
    // clang-format off
    [](std::shared_ptr<Connection> conn, const std::string& bus_name, const std::string& path, const Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
        return std::make_shared<Interface>(conn, bus_name, path, "i.1");
    }
    // clang-format on
};

const AutoRegisterInterface<Interface> registry_i2{
    "i.2",
    // clang-format off
    [](std::shared_ptr<Connection> conn, const std::string& bus_name, const std::string& path, const Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
        return std::make_shared<Interface>(conn, bus_name, path, "i.2");
    }
    // clang-format on
};

const AutoRegisterInterface<Interface> registry_i3{
    "i.3",
    // clang-format off
    [](std::shared_ptr<Connection> conn, const std::string& bus_name, const std::string& path, const Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
        return std::make_shared<Interface>(conn, bus_name, path, "i.3");
    }
    // clang-format on
};

TEST(ProxyInterfaces, LoadInterfaces) {
    Holder managed_interfaces = Holder::create_dict();
    managed_interfaces.dict_append(Holder::STRING, "i.1", Holder());

    Proxy h = Proxy(nullptr, "", "/");
    EXPECT_FALSE(h.interfaces_loaded());

    // TODO: Check that all properties of the interface are correctly loaded.

    h.interfaces_load(managed_interfaces);

    EXPECT_TRUE(h.interfaces_loaded());
    EXPECT_EQ(1, h.interfaces().size());
    EXPECT_EQ(1, h.interfaces().count("i.1"));
}

TEST(ProxyInterfaces, UnloadInterfaces) {
    Holder managed_interfaces = Holder::create_dict();
    managed_interfaces.dict_append(Holder::STRING, "i.1", Holder());
    managed_interfaces.dict_append(Holder::STRING, "i.2", Holder());
    managed_interfaces.dict_append(Holder::STRING, "i.3", Holder());

    Proxy h = Proxy(nullptr, "", "/");
    h.interfaces_load(managed_interfaces);
    EXPECT_EQ(3, h.interfaces_count());

    Holder removed_interfaces = Holder::create_array();
    removed_interfaces.array_append(Holder::create_string("i.3"));
    h.interfaces_unload(removed_interfaces);

    EXPECT_EQ(2, h.interfaces_count());
    EXPECT_TRUE(h.interfaces_loaded());
    EXPECT_FALSE(h.interfaces().at("i.3")->is_loaded());

    removed_interfaces = Holder::create_array();
    removed_interfaces.array_append(Holder::create_string("i.2"));
    h.interfaces_unload(removed_interfaces);

    EXPECT_EQ(1, h.interfaces_count());
    EXPECT_TRUE(h.interfaces_loaded());
    EXPECT_FALSE(h.interfaces().at("i.2")->is_loaded());

    removed_interfaces = Holder::create_array();
    removed_interfaces.array_append(Holder::create_string("i.1"));
    h.interfaces_unload(removed_interfaces);

    EXPECT_EQ(0, h.interfaces_count());
    EXPECT_FALSE(h.interfaces_loaded());
    EXPECT_FALSE(h.interfaces().at("i.1")->is_loaded());
}

TEST(ProxyInterfaces, ReloadInterfaces) {
    Holder managed_interfaces = Holder::create_dict();
    managed_interfaces.dict_append(Holder::STRING, "i.1", Holder());
    managed_interfaces.dict_append(Holder::STRING, "i.2", Holder());
    managed_interfaces.dict_append(Holder::STRING, "i.3", Holder());

    Proxy h = Proxy(nullptr, "", "/");
    h.interfaces_load(managed_interfaces);
    EXPECT_EQ(3, h.interfaces_count());

    managed_interfaces = Holder::create_dict();
    managed_interfaces.dict_append(Holder::STRING, "i.1", Holder());
    managed_interfaces.dict_append(Holder::STRING, "i.3", Holder());
    h.interfaces_reload(managed_interfaces);

    EXPECT_EQ(2, h.interfaces_count());
}