DependencyManagerTestSuite.cc

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#include <gtest/gtest.h>
#include <atomic>
#include <condition_variable>
#include <cstdint>

#include "celix/dm/DependencyManager.h"
#include "celix_framework_factory.h"
#include "framework.h"

class DependencyManagerTestSuite : public ::testing::Test {
public:
    celix_framework_t* fw = nullptr;
    celix_bundle_context_t *ctx = nullptr;
    celix_properties_t *properties = nullptr;

    DependencyManagerTestSuite() {
        properties = celix_properties_create();
        celix_properties_set(properties, "LOGHELPER_ENABLE_STDOUT_FALLBACK", "true");
        celix_properties_setBool(properties, CELIX_FRAMEWORK_CLEAN_CACHE_DIR_ON_CREATE, true);
        celix_properties_set(properties, CELIX_FRAMEWORK_CACHE_DIR, ".cacheBundleContextTestFramework");
        celix_properties_set(properties, "CELIX_LOGGING_DEFAULT_ACTIVE_LOG_LEVEL", "trace");


        fw = celix_frameworkFactory_createFramework(properties);
        ctx = framework_getContext(fw);
    }

    ~DependencyManagerTestSuite() override {
        celix_frameworkFactory_destroyFramework(fw);
    }

    DependencyManagerTestSuite(DependencyManagerTestSuite&&) = delete;
    DependencyManagerTestSuite(const DependencyManagerTestSuite&) = delete;
    DependencyManagerTestSuite& operator=(DependencyManagerTestSuite&&) = delete;
    DependencyManagerTestSuite& operator=(const DependencyManagerTestSuite&) = delete;
};

TEST_F(DependencyManagerTestSuite, DmCreateComponent) {
    auto *mng = celix_bundleContext_getDependencyManager(ctx);
    auto *cmp = celix_dmComponent_create(ctx, "test1");
    celix_dependencyManager_add(mng, cmp);

    ASSERT_EQ(1, celix_dependencyManager_nrOfComponents(mng));
    ASSERT_TRUE(celix_dependencyManager_allComponentsActive(mng));

    cmp = celix_dmComponent_create(ctx, "test2");
    celix_dependencyManager_add(mng, cmp);

    ASSERT_EQ(2, celix_dependencyManager_nrOfComponents(mng));
    ASSERT_TRUE(celix_dependencyManager_allComponentsActive(mng));
}

TEST_F(DependencyManagerTestSuite, DmComponentAddRemove) {
    auto *mng = celix_bundleContext_getDependencyManager(ctx);
    auto *cmp = celix_dmComponent_create(ctx, "test1");
    celix_dependencyManager_add(mng, cmp);
    ASSERT_EQ(1, celix_dependencyManager_nrOfComponents(mng));

    celix_dependencyManager_remove(mng, cmp);
    ASSERT_EQ(0, celix_dependencyManager_nrOfComponents(mng));

    auto *cmp2 = celix_dmComponent_create(ctx, "test2");
    auto *cmp3 = celix_dmComponent_create(ctx, "test3");
    celix_dependencyManager_add(mng, cmp2);
    celix_dependencyManager_add(mng, cmp3);
    ASSERT_EQ(2, celix_dependencyManager_nrOfComponents(mng));

    celix_dependencyManager_removeAllComponents(mng);
    ASSERT_EQ(0, celix_dependencyManager_nrOfComponents(mng));
}

TEST_F(DependencyManagerTestSuite, DmComponentsWithConfiguredDestroyFunction) {
    //Given a simple component implementation (only a name field)
    struct CmpImpl {
        std::string name;
    };

    void(*destroyFn)(CmpImpl*) = [](CmpImpl* impl) {
        std::cout << "Destroying " << impl->name << std::endl;
        delete impl;
    };

    //When 10 of these components impls are created and configured (include destroy impl function)
    //as component in the DM.
    auto* dm = celix_bundleContext_getDependencyManager(ctx);
    for (int i = 0; i < 10; ++i) {
        auto* impl = new CmpImpl{std::string{"Component"} + std::to_string(i+1)};
        auto* dmCmp = celix_dmComponent_create(ctx, impl->name.c_str());
        celix_dmComponent_setImplementation(dmCmp, impl);
        CELIX_DM_COMPONENT_SET_IMPLEMENTATION_DESTROY_FUNCTION(dmCmp, CmpImpl, destroyFn);
        celix_dependencyManager_addAsync(dm, dmCmp);
    }

    //Then all component should become activate (note components with no svc dependencies)
    celix_dependencyManager_wait(dm);
    celix_dependencyManager_allComponentsActive(dm);
    EXPECT_EQ(celix_dependencyManager_nrOfComponents(dm), 10);

    //When all 10 components are removed
    celix_dependencyManager_removeAllComponents(dm);

    //Then all components should be removed
    EXPECT_EQ(celix_dependencyManager_nrOfComponents(dm), 0);

    //And when the test goes out of scope, no memory should be leaked
    //nop
}


TEST_F(DependencyManagerTestSuite, DmComponentAddRemoveAsync) {
    auto *mng = celix_bundleContext_getDependencyManager(ctx);
    auto *cmp1 = celix_dmComponent_create(ctx, "test1");
    celix_dependencyManager_addAsync(mng, cmp1);
    celix_dependencyManager_wait(mng);
    EXPECT_EQ(1, celix_dependencyManager_nrOfComponents(mng));

    std::atomic<std::size_t> count{0};
    auto cb = [](void *data) {
        auto* c = static_cast<std::atomic<std::size_t>*>(data);
        c->fetch_add(1);
    };

    celix_dependencyManager_removeAsync(mng, cmp1, &count, cb);
    celix_dependencyManager_wait(mng);
    EXPECT_EQ(0, celix_dependencyManager_nrOfComponents(mng));
    EXPECT_EQ(1, count.load());
}

TEST_F(DependencyManagerTestSuite, DmComponentRemoveAllAsync) {
    auto *mng = celix_bundleContext_getDependencyManager(ctx);
    auto *cmp1 = celix_dmComponent_create(ctx, "test1");
    auto *cmp2 = celix_dmComponent_create(ctx, "test2");
    celix_dependencyManager_add(mng, cmp1);
    celix_dependencyManager_add(mng, cmp2);
    EXPECT_EQ(2, celix_dependencyManager_nrOfComponents(mng));

    std::atomic<std::size_t> count{0};
    auto callback = [](void *data) {
        auto* c = static_cast<std::atomic<std::size_t>*>(data);
        c->fetch_add(1);
    };
    celix_dependencyManager_removeAllComponentsAsync(mng, &count, callback);
    celix_dependencyManager_wait(mng);
    EXPECT_EQ(0, celix_dependencyManager_nrOfComponents(mng));
    EXPECT_EQ(1, count.load());

    //call again if all components are removed -> should call callback
    celix_dependencyManager_removeAllComponentsAsync(mng, &count, callback);
    celix_dependencyManager_wait(mng);
    EXPECT_EQ(0, celix_dependencyManager_nrOfComponents(mng));
    EXPECT_EQ(2, count.load());
}

TEST_F(DependencyManagerTestSuite, InvalidAddInterface) {
    auto* cmp = celix_dmComponent_create(ctx, "test");
    void* dummyInterfacePointer = (void*)0x42;

    auto status = celix_dmComponent_addInterface(cmp, "", nullptr, dummyInterfacePointer, nullptr);
    EXPECT_NE(status, CELIX_SUCCESS);

    status = celix_dmComponent_addInterface(cmp, nullptr, nullptr, dummyInterfacePointer, nullptr);
    EXPECT_NE(status, CELIX_SUCCESS);

    celix_dmComponent_destroy(cmp);
}

TEST_F(DependencyManagerTestSuite, DmGetInfo) {
    auto* mng = celix_bundleContext_getDependencyManager(ctx);
    auto* cmp = celix_dmComponent_create(ctx, "test1");

    void* dummyInterfacePointer = (void*)0x42;

    auto* p = celix_properties_create();
    celix_properties_set(p, "key", "value");
    celix_dmComponent_addInterface(cmp, "test-interface", nullptr, dummyInterfacePointer, p);

    auto* dep = celix_dmServiceDependency_create();
    celix_dmServiceDependency_setService(dep, "test-interface", nullptr, nullptr);
    celix_dmComponent_addServiceDependency(cmp, dep);

    celix_dependencyManager_add(mng, cmp);

    auto* infos = celix_dependencyManager_createInfos(mng);
    ASSERT_EQ(1, celix_arrayList_size(infos));
    auto* dmInfo = (celix_dependency_manager_info_t*)celix_arrayList_get(infos, 0);
    ASSERT_EQ(1, celix_arrayList_size(dmInfo->components));
    auto *info = (celix_dm_component_info_t*)celix_arrayList_get(dmInfo->components, 0);
    EXPECT_EQ(1, celix_arrayList_size(info->interfaces));
    auto *intInf = (dm_interface_info_t*)celix_arrayList_get(info->interfaces, 0);
    EXPECT_EQ(2, celix_properties_size(intInf->properties)); //key and component.uuid
    EXPECT_EQ(1, celix_arrayList_size(info->dependency_list));
    celix_arrayList_destroy(infos);
}

TEST_F(DependencyManagerTestSuite, DmInterfaceAddRemove) {
    auto *mng = celix_bundleContext_getDependencyManager(ctx);
    auto *cmp = celix_dmComponent_create(ctx, "test1");

    void *dummyInterfacePointer = (void *) 0x42;

    auto *p = celix_properties_create();
    celix_properties_set(p, "key", "value");
    celix_dmComponent_addInterface(cmp, "test-interface", nullptr, dummyInterfacePointer, p);

    auto *dep = celix_dmServiceDependency_create();
    celix_dmServiceDependency_setService(dep, "test-interface", nullptr, nullptr);
    celix_dmComponent_addServiceDependency(cmp, dep);

    celix_dependencyManager_add(mng, cmp);

    celix_dmComponent_removeInterface(cmp, dummyInterfacePointer);

    auto *infos = celix_dependencyManager_createInfos(mng);
    ASSERT_EQ(1, celix_arrayList_size(infos));
    auto *dmInfo = (celix_dependency_manager_info_t *) celix_arrayList_get(infos, 0);
    ASSERT_EQ(1, celix_arrayList_size(dmInfo->components));
    auto *info = (celix_dm_component_info_t *) celix_arrayList_get(dmInfo->components, 0);
    EXPECT_EQ(0, celix_arrayList_size(info->interfaces));
    celix_arrayList_destroy(infos);
}

TEST_F(DependencyManagerTestSuite, TestCheckActive) {
    auto *mng = celix_bundleContext_getDependencyManager(ctx);
    auto *cmp = celix_dmComponent_create(ctx, "test1");

    auto *dep = celix_dmServiceDependency_create();
    celix_dmServiceDependency_setService(dep, "svcname", nullptr, nullptr);
    celix_dmServiceDependency_setRequired(dep, true);
    celix_dmComponent_addServiceDependency(cmp, dep); //required dep -> cmp not active


    celix_dependencyManager_add(mng, cmp);
    ASSERT_FALSE(celix_dependencyManager_areComponentsActive(mng));
}

class TestComponent {

};

struct TestService {
    void *handle = nullptr;
};

class Cmp1 : public TestService {

};

class Cmp2 : public TestService {
public:
    explicit Cmp2(const std::string& name) {
        std::cout << "usage arg: " << name << std::endl;
    }
};

class Cmp3 /*note no inherit*/ {

};


TEST_F(DependencyManagerTestSuite, CxxDmGetInfo) {
    celix::dm::DependencyManager mng{ctx};

    auto& cmp = mng.createComponent<Cmp1>();
    cmp.createProvidedService<TestService>().addProperty("key", "value");
    cmp.createServiceDependency<TestService>().setVersionRange("[1,2)").setRequired(true);

    auto infos = mng.getInfos();
    EXPECT_EQ(infos.size(), 1);

    auto info = mng.getInfo();
    EXPECT_EQ(info.bndId, 0);
    EXPECT_EQ(info.bndSymbolicName, "apache_celix_framework");
    EXPECT_EQ(info.components.size(), 0); //not build yet

    mng.build();
    info = mng.getInfo(); //new info
    ASSERT_EQ(info.components.size(), 1); //build

    auto& cmpInfo = info.components[0];
    EXPECT_TRUE(!cmpInfo.uuid.empty());
    EXPECT_EQ(cmpInfo.name, "Cmp1");
    EXPECT_EQ(cmpInfo.state, "WAITING_FOR_REQUIRED");
    EXPECT_FALSE(cmpInfo.isActive);
    EXPECT_EQ(cmpInfo.nrOfTimesStarted, 0);
    EXPECT_EQ(cmpInfo.nrOfTimesResumed, 0);

    ASSERT_EQ(cmpInfo.interfacesInfo.size(), 1);
    auto& intf = cmpInfo.interfacesInfo[0];
    EXPECT_EQ(intf.serviceName, "TestService");
    EXPECT_TRUE(!intf.properties.empty());
    EXPECT_NE(intf.properties.find("key"), intf.properties.end());

    ASSERT_EQ(cmpInfo.dependenciesInfo.size(), 1);
    auto& dep = cmpInfo.dependenciesInfo[0];
    EXPECT_EQ(dep.serviceName, "TestService");
    EXPECT_EQ(dep.isRequired, true);
    EXPECT_EQ(dep.versionRange, "[1,2)");
    EXPECT_EQ(dep.isAvailable, false);
    EXPECT_EQ(dep.nrOfTrackedServices, 0);
}

TEST_F(DependencyManagerTestSuite, OnlyActiveAfterBuildCheck) {
    celix::dm::DependencyManager dm{ctx};
    EXPECT_EQ(0, dm.getNrOfComponents());

    auto& cmp = dm.createComponent<TestComponent>(std::make_shared<TestComponent>(), "test1");
    EXPECT_EQ(0, dm.getNrOfComponents()); //dm not started yet / comp not build yet
    EXPECT_TRUE(cmp.isValid());

    cmp.build();
    cmp.build(); //should be ok to call twice
    EXPECT_EQ(1, dm.getNrOfComponents()); //cmp "build", so active

    dm.clear();
    dm.clear(); //should be ok to call twice
    EXPECT_EQ(0, dm.getNrOfComponents()); //dm cleared so no components
}

TEST_F(DependencyManagerTestSuite, StartDmWillBuildCmp) {
    celix::dm::DependencyManager dm{ctx};
    EXPECT_EQ(0, dm.getNrOfComponents());

    auto& cmp = dm.createComponent<TestComponent>(std::make_shared<TestComponent>(), "test1");
    EXPECT_EQ(0, dm.getNrOfComponents()); //dm not started yet / comp not build yet
    EXPECT_TRUE(cmp.isValid());

    dm.start();
    EXPECT_EQ(1, dm.getNrOfComponents()); //cmp "build", so active

    dm.stop();
    EXPECT_EQ(0, dm.getNrOfComponents()); //dm cleared so no components
}

TEST_F(DependencyManagerTestSuite, CreateComponentVariant) {
    celix::dm::DependencyManager dm{ctx};

    dm.createComponent<Cmp1>().addInterface<TestService>(); //lazy
    dm.createComponent(std::unique_ptr<Cmp1>{new Cmp1}).addInterface<TestService>(); //with unique ptr
    dm.createComponent(std::make_shared<Cmp1>()).addInterface<TestService>(); //with shared ptr
    dm.createComponent(Cmp1{}).addInterface<TestService>(); //with value

    //dm.createComponent<Cmp2>(); //Does not compile ->  no default ctor
    dm.createComponent(std::unique_ptr<Cmp2>{new Cmp2{"a"}}).addInterface<TestService>(); //with unique ptr
    dm.createComponent(std::make_shared<Cmp2>("b")).addInterface<TestService>();; //with shared ptr
    dm.createComponent(Cmp2{"c"}).addInterface<TestService>();; //with value

    dm.start();
}

TEST_F(DependencyManagerTestSuite, AddSvcProvideAfterBuild) {
    celix::dm::DependencyManager dm{ctx};
    EXPECT_EQ(0, dm.getNrOfComponents());

    auto& cmp = dm.createComponent<TestComponent>(std::make_shared<TestComponent>(), "test1");
    EXPECT_EQ(0, dm.getNrOfComponents()); //dm not started yet / comp not build yet
    EXPECT_TRUE(cmp.isValid());

    cmp.build();
    EXPECT_EQ(1, dm.getNrOfComponents()); //cmp "build", so active

    TestService svc{};
    cmp.addCInterface(&svc, "TestService");

    long svcId = celix_bundleContext_findService(ctx, "TestService");
    EXPECT_EQ(-1, svcId); //not build -> not found

    cmp.build();
    cmp.build(); //should be ok to call twice
    svcId = celix_bundleContext_findService(ctx, "TestService");
    EXPECT_GT(svcId, -1); //(re)build -> found

    dm.clear();
    dm.wait();
    dm.waitIfAble();
    EXPECT_EQ(0, dm.getNrOfComponents()); //dm cleared so no components
    svcId = celix_bundleContext_findService(ctx, "TestService");
    EXPECT_EQ(svcId, -1); //cleared -> not found
}

TEST_F(DependencyManagerTestSuite, BuildSvcProvide) {
    celix::dm::DependencyManager dm{ctx};
    EXPECT_EQ(0, dm.getNrOfComponents());

    auto& cmp = dm.createComponent<Cmp1>(std::make_shared<Cmp1>(), "test2");
    EXPECT_EQ(0, dm.getNrOfComponents()); //dm not started yet / comp not build yet
    EXPECT_TRUE(cmp.isValid());

    cmp.build();
    EXPECT_EQ(1, dm.getNrOfComponents()); //cmp "build", so active

    TestService svc{};
    cmp.createProvidedCService(&svc, "CTestService").addProperty("key1", "val1").addProperty("key2", 3);

    long svcId = celix_bundleContext_findService(ctx, "CTestService");
    EXPECT_EQ(-1, svcId); //not build -> not found

    cmp.build();
    cmp.build(); //should be ok to call twice
    dm.wait();
    svcId = celix_bundleContext_findService(ctx, "CTestService");
    EXPECT_GT(svcId, -1); //(re)build -> found

    celix_service_filter_options_t opts{};
    opts.serviceName = "CTestService";
    opts.filter = "(&(key1=val1)(key2=3))";
    svcId = celix_bundleContext_findServiceWithOptions(ctx, &opts);
    EXPECT_GT(svcId, -1); //found, so properties present

    celix::dm::Properties props{};
    props["key1"] = "value";
    cmp.createProvidedService<TestService>().setProperties(props).setVersion("1.0.0").build();

    opts.serviceName = "TestService";
    opts.filter = "(key1=value)";
    svcId = celix_bundleContext_findServiceWithOptions(ctx, &opts);
    EXPECT_GT(svcId, -1); //found, so properties present

    dm.clear();
    dm.wait();
    EXPECT_EQ(0, dm.getNrOfComponents()); //dm cleared so no components
    svcId = celix_bundleContext_findService(ctx, "CTestService");
    EXPECT_EQ(svcId, -1); //cleared -> not found
}

TEST_F(DependencyManagerTestSuite, BuildUnassociatedProvidedService) {
    celix::dm::DependencyManager dm{ctx};

    //Given a component which does not inherit any interfaces
    auto& cmp = dm.createComponent<Cmp1>(std::make_shared<Cmp1>());

    //Then I can create a provided service using a shared_ptr which is not associated with the component type
    // (TestService is not a base of Cmp3)
    cmp.createUnassociatedProvidedService(std::make_shared<TestService>())
        .addProperty("test1", "value1");

    //And I can create a provided service using a shared_ptr and a custom name
    cmp.createUnassociatedProvidedService(std::make_shared<TestService>(), "CustomName");

    //When I build the component
    cmp.build();

    //Then the nr of component is 1
    ASSERT_EQ(1, dm.getNrOfComponents()); //cmp "build", so active

    //And the nr of provided interfaces of that component is 2
    auto info = dm.getInfo();
    ASSERT_EQ(info.components[0].interfacesInfo.size(), 2);

    //And the first (index 0) provided service has a name TestService and a property test1 with value value1
    EXPECT_STREQ(info.components[0].interfacesInfo[0].serviceName.c_str(), "TestService");
    EXPECT_STREQ(info.components[0].interfacesInfo[0].properties["test1"].c_str(), "value1");

    //And the second (index 1) provide service has a name "CustomName".
    EXPECT_STREQ(info.components[0].interfacesInfo[1].serviceName.c_str(), "CustomName");
}


TEST_F(DependencyManagerTestSuite, AddSvcDepAfterBuild) {
    celix::dm::DependencyManager dm{ctx};
    EXPECT_EQ(0, dm.getNrOfComponents());

    auto& cmp = dm.createComponent<TestComponent>(std::make_shared<TestComponent>(), "test1");
    EXPECT_EQ(0, dm.getNrOfComponents()); //dm not started yet / comp not build yet
    EXPECT_TRUE(cmp.isValid());

    cmp.build();
    cmp.build(); //should be ok to call twice
    EXPECT_EQ(1, dm.getNrOfComponents()); //cmp "build", so active

    std::atomic<int> count{0};
    auto& dep = cmp.createCServiceDependency<TestService>("TestService")
            .setCallbacks([&count](const TestService*, celix::dm::Properties&&) {
                count++;
            });

    TestService svc{};
    long svcId = celix_bundleContext_registerService(ctx, &svc, "TestService", nullptr);
    long svcId2 = celix_bundleContext_registerService(ctx, &svc, "AnotherService", nullptr); //note should not be found.

    ASSERT_EQ(0, count); //service dep not yet build -> so no set call

    dep.build();
    dep.build(); //should be ok to call twice
    celix_bundleContext_waitForEvents(ctx);
    ASSERT_EQ(1, count); //service dep build -> so count is 1;

    //create another service dep
    cmp.createCServiceDependency<TestService>("TestService")
            .setCallbacks([&count](const TestService*, celix::dm::Properties&&) {
                count++;
            });
    ASSERT_EQ(1, count); //new service dep not yet build -> so count still 1

    cmp.build(); //cmp build, which will build svc dep
    ASSERT_EQ(2, count); //new service dep build -> so count is 2

    celix_bundleContext_unregisterService(ctx, svcId);
    celix_bundleContext_unregisterService(ctx, svcId2);
}

TEST_F(DependencyManagerTestSuite, InCompleteBuildShouldNotLeak) {
    celix::dm::DependencyManager dm{ctx};
    dm.createComponent<TestComponent>(std::make_shared<TestComponent>(), "test1"); //NOTE NOT BUILD

    auto& cmp2 = dm.createComponent<Cmp1>(std::make_shared<Cmp1>(), "test2").build(); //NOTE BUILD
    cmp2.createCServiceDependency<TestService>("TestService").setFilter("(key=value"); //note not build
    cmp2.createServiceDependency<TestService>().setFilter("(key=value)").setName("alternative name"); //note not build

    TestService svc{};
    cmp2.createProvidedCService(&svc, "CTestService").addProperty("key1", "val1"); //note not build
    cmp2.createProvidedService<TestService>().setVersion("1.0.0"); //note not build
}


TEST_F(DependencyManagerTestSuite, RemoveAndClear) {
    celix::dm::DependencyManager dm{ctx};
    auto& cmp1 = dm.createComponent<TestComponent>(std::make_shared<TestComponent>()).build();
    auto& cmp2 = dm.createComponent<TestComponent>(std::make_shared<TestComponent>()).build();
    dm.createComponent<TestComponent>(std::make_shared<TestComponent>()).build();
    auto& cmp4 = dm.createComponent<TestComponent>(std::make_shared<TestComponent>());
    dm.wait();

    dm.destroyComponent(cmp1);
    bool removed = dm.removeComponent(cmp2.getUUID());
    EXPECT_TRUE(removed);
    removed = dm.removeComponentAsync(cmp4.getUUID());
    EXPECT_TRUE(removed);
    dm.clear();
}

TEST_F(DependencyManagerTestSuite, RequiredDepsAreInjectedDuringStartStop) {
    class LifecycleComponent {
    public:
        void start() {
            std::lock_guard<std::mutex> lck{mutex};
            EXPECT_TRUE(setSvc != nullptr);
            EXPECT_EQ(services.size(), 1);
        }

        void stop() {
            std::lock_guard<std::mutex> lck{mutex};
            EXPECT_TRUE(setSvc != nullptr);
            EXPECT_EQ(services.size(), 1);
        }

        void setService(TestService* svc) {
            std::lock_guard<std::mutex> lck{mutex};
            setSvc = svc;
        }

        void addService(TestService* svc) {
            std::lock_guard<std::mutex> lck{mutex};
            services.emplace_back(svc);
        }

        void remService(TestService* svc) {
            std::lock_guard<std::mutex> lck{mutex};
            for (auto it = services.begin(); it != services.end(); ++it) {
                if (*it == svc) {
                    services.erase(it);
                    break;
                }
            }
        }
    private:
        std::mutex mutex{};
        TestService* setSvc{};
        std::vector<TestService*> services{};
    };

    celix::dm::DependencyManager dm{ctx};
    auto& cmp = dm.createComponent<LifecycleComponent>()
            .setCallbacks(nullptr, &LifecycleComponent::start, &LifecycleComponent::stop, nullptr);
    cmp.createServiceDependency<TestService>()
            .setRequired(true)
            .setCallbacks(&LifecycleComponent::setService)
            .setCallbacks(&LifecycleComponent::addService, &LifecycleComponent::remService);
    cmp.build();

    TestService svc;
    std::string svcName = celix::typeName<TestService>();
    celix_service_registration_options opts{};
    opts.svc = &svc;
    opts.serviceName = svcName.c_str();
    long svcId = celix_bundleContext_registerServiceWithOptions(dm.bundleContext(), &opts);
    EXPECT_GE(svcId, 0);

    EXPECT_EQ(cmp.getState(), ComponentState::TRACKING_OPTIONAL);
    celix_bundleContext_unregisterService(dm.bundleContext(), svcId);
}

TEST_F(DependencyManagerTestSuite, RemoveOwnDependencyShouldNotLeadToDoubleStop) {
    //Given a component LifecycleComponent which provides and requires a TestService service
    class LifecycleComponent : public TestService {
    public:
        void start() {
            startCount.fetch_add(1);
        }

        void stop() {
            stopCount.fetch_add(1);
        }

        int getStartCount() const { return startCount.load(); }

        int getStopCount() const { return stopCount.load(); }
    private:
        std::atomic<int> startCount{0};
        std::atomic<int> stopCount{0};
    };

    celix::dm::DependencyManager dm{ctx};
    auto lifecycleCmp = std::make_shared<LifecycleComponent>();
    auto& cmp = dm.createComponent<LifecycleComponent>(lifecycleCmp)
            .setCallbacks(nullptr, &LifecycleComponent::start, &LifecycleComponent::stop, nullptr);
    cmp.createProvidedService<TestService>();
    cmp.createServiceDependency<TestService>()
            .setRequired(true);
    cmp.build();
    using celix::dm::ComponentState;

    //Then the component state should be waiting for required
    EXPECT_EQ(cmp.getState(), ComponentState::WAITING_FOR_REQUIRED);

    //When a TestService is registered
    TestService svc{};
    long svcId = celix_bundleContext_registerService(ctx, &svc, "TestService", nullptr);
    celix_bundleContext_waitForEvents(ctx);

    //Then the component state should become tracking optional (active)
    EXPECT_EQ(cmp.getState(), ComponentState::TRACKING_OPTIONAL);
    //And the start count should become 1
    EXPECT_EQ(lifecycleCmp->getStartCount(), 1);

    //When the TestService is unregistered
    celix_bundleContext_unregisterService(ctx, svcId);

    //Then the component state will stay tracking optional (because it now depends on its own provided services)
    EXPECT_EQ(cmp.getState(), ComponentState::TRACKING_OPTIONAL);
    EXPECT_EQ(lifecycleCmp->getStopCount(), 0);

    //When an additional required service dependency is added
    cmp.createServiceDependency<TestService>("DummyName")
            .setRequired(true)
            .buildAsync();

    celix_bundleContext_waitForEvents(ctx);
    //Then the component state becomes waiting for required
    EXPECT_EQ(cmp.getState(), ComponentState::INSTANTIATED_AND_WAITING_FOR_REQUIRED);
    //And the stop count becomes 1 (not 2 becomes of a loop the dm component handling)
    EXPECT_EQ(lifecycleCmp->getStopCount(), 1);
}


TEST_F(DependencyManagerTestSuite, IntermediateStatesDuringInitDeinitStartingAndStopping) {
    //Given a component LifecycleComponent with an optional service dependency on TestService with a suspend-strategy
    //and a required service dependency on "RequiredTestService" with a locking-strategy.
    class LifecycleComponent {
    public:
        enum class LifecycleMethod : std::int8_t {
            None =      0,
            Init =      1,
            Start =     2,
            Stop =      3,
            Deinit =    4,
        };

        void init() {
            std::cout << "in init callback\n";
            setStateAndWaitToContinue(LifecycleMethod::Init);
        }

        void deinit() {
            std::cout << "in deinit callback\n";
            setStateAndWaitToContinue(LifecycleMethod::Deinit);
        }

        void start() {
            std::cout << "in start callback\n";
            setStateAndWaitToContinue(LifecycleMethod::Start);
        }

        void stop() {
            std::cout << "in stop callback\n";
            setStateAndWaitToContinue(LifecycleMethod::Stop);
        }

        void setStayInMethod(LifecycleMethod m) {
            std::lock_guard<std::mutex> lck{mutex};
            stayInMethod = m;
            cond.notify_all();
        }

        void waitUntilInMethod(LifecycleMethod m) {
            std::unique_lock<std::mutex> lck{mutex};
            cond.wait_for(lck, std::chrono::seconds{5}, [&]{ return currentMethod == m; });
        }
    private:
        void setStateAndWaitToContinue(LifecycleMethod m) {
            std::unique_lock<std::mutex> lck{mutex};
            currentMethod = m;
            cond.notify_all();
            cond.wait_for(lck, std::chrono::seconds{5}, [&] { return currentMethod != stayInMethod; });
            currentMethod = LifecycleMethod::None;
            cond.notify_all();
        }

        std::mutex mutex{};
        std::condition_variable cond{};
        LifecycleMethod stayInMethod = LifecycleMethod::None;
        LifecycleMethod currentMethod = LifecycleMethod::None;
    };
    using LifecycleMethod = LifecycleComponent::LifecycleMethod;


    celix::dm::DependencyManager dm{ctx};
    auto lifecycleCmp = std::make_shared<LifecycleComponent>();
    auto& cmp = dm.createComponent<LifecycleComponent>(lifecycleCmp)
            .setCallbacks(&LifecycleComponent::init, &LifecycleComponent::start, &LifecycleComponent::stop, &LifecycleComponent::deinit);
    cmp.createServiceDependency<TestService>()
            .setStrategy(celix::dm::DependencyUpdateStrategy::suspend)
            .setCallbacks([](std::shared_ptr<TestService> /*service*/, const std::shared_ptr<const celix::Properties>& /*properties*/){ std::cout << "Dummy set for svc callback\n"; })
            .setRequired(false);
    cmp.createServiceDependency<TestService>("RequiredTestService")
            .setStrategy(celix::dm::DependencyUpdateStrategy::locking)
            .setRequired(true);
    cmp.buildAsync();

    //Then the component state should become waiting for required
    cmp.wait();
    EXPECT_EQ(cmp.getState(), ComponentState::WAITING_FOR_REQUIRED);

    //When the component should wait in the init callback
    lifecycleCmp->setStayInMethod(LifecycleMethod::Init);

    //And a "RequiredTestService" service is registered
    TestService reqSvc{};
    long reqSvcId = celix_bundleContext_registerServiceAsync(ctx, &reqSvc, "RequiredTestService", nullptr);
    EXPECT_GE(reqSvcId, 0);

    //Then the component state should become initializing
    using celix::dm::ComponentState;
    lifecycleCmp->waitUntilInMethod(LifecycleMethod::Init);
    EXPECT_EQ(cmp.getState(), ComponentState::INITIALIZING);

    //When the component should wait in the start callback
    //Then the component state should become starting
    lifecycleCmp->setStayInMethod(LifecycleMethod::Start);
    lifecycleCmp->waitUntilInMethod(LifecycleMethod::Start);
    EXPECT_EQ(cmp.getState(), ComponentState::STARTING);

    //When the component should not wait in the lifecycle callbacks
    lifecycleCmp->setStayInMethod(LifecycleMethod::None);

    //Then the component state should become tracking optional
    cmp.wait();
    EXPECT_EQ(cmp.getState(), ComponentState::TRACKING_OPTIONAL);


    //When the component should wait in the stop callback
    lifecycleCmp->setStayInMethod(LifecycleMethod::Stop);

    //And a new TestService is registered (leading to a suspending of the component)
    TestService svc;
    std::string svcName = celix::typeName<TestService>();
    celix_service_registration_options opts{};
    opts.svc = &svc;
    opts.serviceName = svcName.c_str();
    long optionalSvcId = celix_bundleContext_registerServiceWithOptionsAsync(dm.bundleContext(), &opts);
    EXPECT_GE(optionalSvcId, 0);

    //Then the component state should become suspending
    lifecycleCmp->waitUntilInMethod(LifecycleMethod::Stop);
    EXPECT_EQ(cmp.getState(), ComponentState::SUSPENDING);

    //When the component should wait in the start callback
    //Then the component state should become resuming (suspending->suspended->resuming)
    lifecycleCmp->setStayInMethod(LifecycleMethod::Start);
    lifecycleCmp->waitUntilInMethod(LifecycleMethod::Start);
    EXPECT_EQ(cmp.getState(), ComponentState::RESUMING);

    //When the component should not wait in the lifecycle callbacks
    lifecycleCmp->setStayInMethod(LifecycleMethod::None);

    //Then the component state should become tracking optional
    cmp.wait();
    EXPECT_EQ(cmp.getState(), ComponentState::TRACKING_OPTIONAL);

    //When the component should wait in the stop callback
    lifecycleCmp->setStayInMethod(LifecycleMethod::Stop);

    //And the "RequiredTestService" is unregistered
    celix_bundleContext_unregisterServiceAsync(ctx, reqSvcId, nullptr, nullptr);

    //Then the component state should become stopping
    lifecycleCmp->waitUntilInMethod(LifecycleMethod::Stop);
    EXPECT_EQ(cmp.getState(), ComponentState::STOPPING);

    //When the component should not wait in the lifecycle callbacks
    lifecycleCmp->setStayInMethod(LifecycleMethod::None);

    //Then the component state should become instantiated and waiting for required
    cmp.wait();
    EXPECT_EQ(cmp.getState(), ComponentState::INSTANTIATED_AND_WAITING_FOR_REQUIRED);

    //When the component should wait in the deinit callback
    lifecycleCmp->setStayInMethod(LifecycleMethod::Deinit);

    //And the component is removed from the dependency manager
    dm.removeComponentAsync(cmp.getUUID());

    //Then the component state should become deinitializing
    lifecycleCmp->waitUntilInMethod(LifecycleMethod::Deinit);
    EXPECT_EQ(cmp.getState(), ComponentState::DEINITIALIZING);

    lifecycleCmp->setStayInMethod(LifecycleMethod::None);
    celix_bundleContext_unregisterService(dm.bundleContext(), optionalSvcId);
}

TEST_F(DependencyManagerTestSuite, DepsAreInjectedAsSharedPointers) {
    class LifecycleComponent {
    public:
        void start() {
            std::lock_guard<std::mutex> lck{mutex};
            EXPECT_TRUE(setSvc != nullptr);
            EXPECT_EQ(services.size(), 1);
        }

        void stop() {
            std::lock_guard<std::mutex> lck{mutex};
            EXPECT_TRUE(setSvc != nullptr);
            EXPECT_EQ(services.size(), 1);
        }

        void setService(const std::shared_ptr<TestService>& svc, const std::shared_ptr<const celix::Properties>& /*props*/) {
            std::lock_guard<std::mutex> lck{mutex};
            setSvc = svc;
        }

        void addService(const std::shared_ptr<TestService>& svc, const std::shared_ptr<const celix::Properties>& props) {
            EXPECT_TRUE(props);
            std::lock_guard<std::mutex> lck{mutex};
            services.emplace_back(svc);
        }

        void remService(const std::shared_ptr<TestService>& svc, const std::shared_ptr<const celix::Properties>& props) {
            EXPECT_TRUE(props);
            std::lock_guard<std::mutex> lck{mutex};
            for (auto it = services.begin(); it != services.end(); ++it) {
                if (*it == svc) {
                    services.erase(it);
                    break;
                }
            }
        }
    private:
        std::mutex mutex{};
        std::shared_ptr<TestService> setSvc{};
        std::vector<std::shared_ptr<TestService>> services{};
    };

    celix::dm::DependencyManager dm{ctx};
    auto& cmp = dm.createComponent<LifecycleComponent>()
            .setCallbacks(nullptr, &LifecycleComponent::start, &LifecycleComponent::stop, nullptr);
    cmp.createServiceDependency<TestService>()
            .setRequired(true)
            .setCallbacks(&LifecycleComponent::setService)
            .setCallbacks(&LifecycleComponent::addService, &LifecycleComponent::remService);
    cmp.build();

    TestService svc;
    std::string svcName = celix::typeName<TestService>();
    celix_service_registration_options opts{};
    opts.svc = &svc;
    opts.serviceName = svcName.c_str();
    long svcId = celix_bundleContext_registerServiceWithOptions(dm.bundleContext(), &opts);
    EXPECT_GE(svcId, 0);

    EXPECT_EQ(cmp.getState(), ComponentState::TRACKING_OPTIONAL);
    celix_bundleContext_unregisterService(dm.bundleContext(), svcId);
}

TEST_F(DependencyManagerTestSuite, DepsNoPropsAreInjectedAsSharedPointers) {
    class LifecycleComponent {
    public:
        void start() {
            std::lock_guard<std::mutex> lck{mutex};
            EXPECT_TRUE(setSvc != nullptr);
            EXPECT_EQ(services.size(), 1);
        }

        void stop() {
            std::lock_guard<std::mutex> lck{mutex};
            EXPECT_TRUE(setSvc != nullptr);
            EXPECT_EQ(services.size(), 1);
        }

        void setService(const std::shared_ptr<TestService>& svc) {
            std::lock_guard<std::mutex> lck{mutex};
            setSvc = svc;
        }

        void addService(const std::shared_ptr<TestService>& svc) {
            std::lock_guard<std::mutex> lck{mutex};
            services.emplace_back(svc);
        }

        void remService(const std::shared_ptr<TestService>& svc) {
            std::lock_guard<std::mutex> lck{mutex};
            for (auto it = services.begin(); it != services.end(); ++it) {
                if (*it == svc) {
                    services.erase(it);
                    break;
                }
            }
        }
    private:
        std::mutex mutex{};
        std::shared_ptr<TestService> setSvc{};
        std::vector<std::shared_ptr<TestService>> services{};
    };

    celix::dm::DependencyManager dm{ctx};
    auto& cmp = dm.createComponent<LifecycleComponent>()
            .setCallbacks(nullptr, &LifecycleComponent::start, &LifecycleComponent::stop, nullptr);
    cmp.createServiceDependency<TestService>()
            .setRequired(true)
            .setCallbacks(&LifecycleComponent::setService)
            .setCallbacks(&LifecycleComponent::addService, &LifecycleComponent::remService);
    cmp.build();

    TestService svc;
    std::string svcName = celix::typeName<TestService>();
    celix_service_registration_options opts{};
    opts.svc = &svc;
    opts.serviceName = svcName.c_str();
    long svcId = celix_bundleContext_registerServiceWithOptions(dm.bundleContext(), &opts);
    EXPECT_GE(svcId, 0);

    EXPECT_EQ(cmp.getState(), ComponentState::TRACKING_OPTIONAL);
    celix_bundleContext_unregisterService(dm.bundleContext(), svcId);
}

TEST_F(DependencyManagerTestSuite, UnneededSuspendIsPrevented) {
    class CounterComponent {
    public:
        void start() {
            startCount++;
        }

        void stop() {
            stopCount++;
        }

        void setService(TestService* /*svc*/) {
            //nop
        }

        void addService(TestService* /*svc*/) {
            //nop
        }

        void remService(TestService* /*svc*/) {
            //nop
        }

        std::atomic<int> startCount{0};
        std::atomic<int> stopCount{0};
    };

    celix::dm::DependencyManager dm{ctx};
    //cmp1 has lifecycle callbacks, but not set or add/rem callbacks for the service dependency -> should not trigger suspend
    auto& cmp1 = dm.createComponent<CounterComponent>("CounterCmp1")
            .setCallbacks(nullptr, &CounterComponent::start, &CounterComponent::stop, nullptr);
    cmp1.createServiceDependency<TestService>();
    cmp1.build();

    //cmp2 has lifecycle callbacks and set, add/rem callbacks for the service dependency -> should trigger suspend 2x
    auto& cmp2 = dm.createComponent<CounterComponent>("CounterCmp2")
            .setCallbacks(nullptr, &CounterComponent::start, &CounterComponent::stop, nullptr);
    cmp2.createServiceDependency<TestService>()
            .setCallbacks(&CounterComponent::setService)
            .setCallbacks(&CounterComponent::addService, &CounterComponent::remService);
    cmp2.build();

    EXPECT_EQ(cmp1.getState(), celix::dm::ComponentState::TRACKING_OPTIONAL);
    EXPECT_EQ(cmp2.getState(), celix::dm::ComponentState::TRACKING_OPTIONAL);

    TestService svc;
    std::string svcName = celix::typeName<TestService>();
    celix_service_registration_options opts{};
    opts.svc = &svc;
    opts.serviceName = svcName.c_str();
    long svcId = celix_bundleContext_registerServiceWithOptions(dm.bundleContext(), &opts);
    EXPECT_GE(svcId, 0);

    EXPECT_EQ(cmp1.getInstance().startCount, 1); //only once during creation
    EXPECT_EQ(cmp1.getInstance().stopCount, 0);
    EXPECT_EQ(cmp2.getInstance().startCount, 3); //1x creation, 1x suspend for set, 1x suspend for add
    EXPECT_EQ(cmp2.getInstance().stopCount, 2); //1x suspend for set, 1x suspend for add

    cmp1.getInstance().startCount = 0;
    cmp1.getInstance().stopCount = 0;
    cmp2.getInstance().startCount = 0;
    cmp2.getInstance().stopCount = 0;
    celix_bundleContext_unregisterService(dm.bundleContext(), svcId);

    EXPECT_EQ(cmp1.getInstance().startCount, 0);
    EXPECT_EQ(cmp1.getInstance().stopCount, 0);
    EXPECT_EQ(cmp2.getInstance().startCount, 2); //1x suspend for set nullptr, 1x suspend for rem
    EXPECT_EQ(cmp2.getInstance().stopCount, 2); //1x suspend for set nullptr, 1x suspend for rem
}

TEST_F(DependencyManagerTestSuite, ExceptionsInLifecycle) {
    class ExceptionComponent {
    public:
        enum class LifecycleMethod : std::uint8_t {
            INIT,
            START,
            STOP,
            DEINIT
        };

        explicit ExceptionComponent(LifecycleMethod _failAt) : failAt{_failAt} {}

        void failFor(LifecycleMethod lm) {
            if (lm == failAt) {
                throw std::logic_error("fail test");
            }
        }

        void init() {
            failFor(LifecycleMethod::INIT);
        }

        void start() {
            failFor(LifecycleMethod::START);
        }

        void stop() {
            failFor(LifecycleMethod::STOP);
        }

        void deinit() {
            failFor(LifecycleMethod::DEINIT);
        }

    private:
        const LifecycleMethod failAt;
    };

    celix::dm::DependencyManager dm{ctx};

    {
        auto& cmp = dm.createComponent(std::make_shared<ExceptionComponent>(ExceptionComponent::LifecycleMethod::INIT), "FailAtInitCmp")
                .setCallbacks(&ExceptionComponent::init, &ExceptionComponent::start, &ExceptionComponent::stop, &ExceptionComponent::deinit);
        EXPECT_EQ(cmp.getState(), ComponentState::INACTIVE);
        cmp.build(); //fails at init and should disable
        EXPECT_EQ(cmp.getState(), ComponentState::INACTIVE);
        dm.clear();
    }

    {
        auto& cmp = dm.createComponent(std::make_shared<ExceptionComponent>(ExceptionComponent::LifecycleMethod::START), "FailAtStartCmp")
                .setCallbacks(&ExceptionComponent::init, &ExceptionComponent::start, &ExceptionComponent::stop, &ExceptionComponent::deinit);
        EXPECT_EQ(cmp.getState(), ComponentState::INACTIVE);
        cmp.build(); //fails at init and should disable
        EXPECT_EQ(cmp.getState(), ComponentState::INACTIVE);
        dm.clear();
    }

    {
        auto& cmp = dm.createComponent(std::make_shared<ExceptionComponent>(ExceptionComponent::LifecycleMethod::STOP), "FailAtStopCmp")
                .setCallbacks(&ExceptionComponent::init, &ExceptionComponent::start, &ExceptionComponent::stop, &ExceptionComponent::deinit);
        EXPECT_EQ(cmp.getState(), ComponentState::INACTIVE);
        cmp.build();
        EXPECT_EQ(cmp.getState(), ComponentState::TRACKING_OPTIONAL);

        //required service -> should stop, but fails at stop and should become inactive (component will disable itself)
        cmp.createServiceDependency<TestService>().setRequired(true).build();
        cmp.wait();
        EXPECT_EQ(cmp.getState(), ComponentState::INACTIVE);
        dm.clear();
    }

    {
        auto& cmp = dm.createComponent(std::make_shared<ExceptionComponent>(ExceptionComponent::LifecycleMethod::DEINIT), "FailAtDeinit")
                .setCallbacks(&ExceptionComponent::init, &ExceptionComponent::start, &ExceptionComponent::stop, &ExceptionComponent::deinit);
        EXPECT_EQ(cmp.getState(), ComponentState::INACTIVE);
        cmp.build();
        EXPECT_EQ(cmp.getState(), ComponentState::TRACKING_OPTIONAL);

        //required service -> should stop, but fails at stop and should become inactive (component will disable itself)
        dm.clear(); //dm clear will deinit component and this should fail, but not deadlock
    }
}

TEST_F(DependencyManagerTestSuite, ComponentContextShouldNotLeak) {
    celix::dm::DependencyManager dm{ctx};
    dm.createComponent<TestComponent>()
            .addContext(std::make_shared<std::vector<std::string>>())
            .build();
    //note should not leak mem
}

TEST_F(DependencyManagerTestSuite, installBundleWithDepManActivator) {
    auto* list = celix_bundleContext_listBundles(ctx);
    EXPECT_EQ(celix_arrayList_size(list), 0);
    celix_arrayList_destroy(list);

    auto bndId = celix_bundleContext_installBundle(ctx, SIMPLE_CXX_DEP_MAN_BUNDLE_LOC, true);
    EXPECT_GT(bndId, CELIX_FRAMEWORK_BUNDLE_ID);

    list = celix_bundleContext_listBundles(ctx);
    EXPECT_EQ(celix_arrayList_size(list), 1);
    celix_arrayList_destroy(list);
}

TEST_F(DependencyManagerTestSuite, testStateToString) {
    const char* state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_INACTIVE);
    EXPECT_STREQ(state, "INACTIVE");
    state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_WAITING_FOR_REQUIRED);
    EXPECT_STREQ(state, "WAITING_FOR_REQUIRED");
    state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_INITIALIZING);
    EXPECT_STREQ(state, "INITIALIZING");
    state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_DEINITIALIZING);
    EXPECT_STREQ(state, "DEINITIALIZING");
    state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_INITIALIZED_AND_WAITING_FOR_REQUIRED);
    EXPECT_STREQ(state, "INITIALIZED_AND_WAITING_FOR_REQUIRED");
    state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_STARTING);
    EXPECT_STREQ(state, "STARTING");
    state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_STOPPING);
    EXPECT_STREQ(state, "STOPPING");
    state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_TRACKING_OPTIONAL);
    EXPECT_STREQ(state, "TRACKING_OPTIONAL");
    state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_SUSPENDING);
    EXPECT_STREQ(state, "SUSPENDING");
    state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_SUSPENDED);
    EXPECT_STREQ(state, "SUSPENDED");
    state = celix_dmComponent_stateToString(CELIX_DM_CMP_STATE_RESUMING);
    EXPECT_STREQ(state, "RESUMING");
    state = celix_dmComponent_stateToString((celix_dm_component_state_enum)0);
    EXPECT_STREQ(state, "INACTIVE");
    state = celix_dmComponent_stateToString((celix_dm_component_state_enum)16);
    EXPECT_STREQ(state, "INACTIVE");

    //test deprecated dm cmp states
    state = celix_dmComponent_stateToString(DM_CMP_STATE_INACTIVE);
    EXPECT_STREQ(state, "INACTIVE");
    state = celix_dmComponent_stateToString(DM_CMP_STATE_INSTANTIATED_AND_WAITING_FOR_REQUIRED);
    EXPECT_STREQ(state, "INITIALIZED_AND_WAITING_FOR_REQUIRED");
    state = celix_dmComponent_stateToString(DM_CMP_STATE_TRACKING_OPTIONAL);
    EXPECT_STREQ(state, "TRACKING_OPTIONAL");
    state = celix_dmComponent_stateToString(DM_CMP_STATE_WAITING_FOR_REQUIRED);
    EXPECT_STREQ(state, "WAITING_FOR_REQUIRED");

}

class TestInterface {
public:
    static constexpr const char * const NAME = "TestName";
    static constexpr const char * const VERSION = "1.2.3";
};

TEST_F(DependencyManagerTestSuite, ProvideInterfaceInfo) {
    class TestComponent : public TestInterface {};
    celix::dm::DependencyManager dm{ctx};
    auto& cmp = dm.createComponent<TestComponent>();
    cmp.createProvidedService<TestInterface>(TestInterface::NAME)
            .setVersion(TestInterface::VERSION);
    cmp.build();
    EXPECT_EQ(cmp.getState(), celix::dm::ComponentState::TRACKING_OPTIONAL);

    auto info = dm.getInfo();
    EXPECT_EQ(info.components[0].interfacesInfo[0].serviceName, "TestName");
    auto& props = info.components[0].interfacesInfo[0].properties;
    const auto it = props.find(celix::SERVICE_VERSION);
    ASSERT_TRUE(it != props.end());
    EXPECT_EQ(it->second, "1.2.3");
}

TEST_F(DependencyManagerTestSuite, CreateInterfaceInfo) {
    class TestComponent : public TestInterface {};
    celix::dm::DependencyManager dm{ctx};
    auto& cmp = dm.createComponent<TestComponent>();
    cmp.addInterfaceWithName<TestInterface>(TestInterface::NAME, TestInterface::VERSION);
    cmp.build();
    EXPECT_EQ(cmp.getState(), celix::dm::ComponentState::TRACKING_OPTIONAL);

    auto info = dm.getInfo();
    EXPECT_EQ(info.components[0].interfacesInfo[0].serviceName, "TestName");
    auto& props = info.components[0].interfacesInfo[0].properties;
    const auto it = props.find(celix::SERVICE_VERSION);
    ASSERT_TRUE(it != props.end());
    EXPECT_EQ(it->second, "1.2.3");
}

TEST_F(DependencyManagerTestSuite, TestPrintInfo) {
    celix::dm::DependencyManager dm{ctx};
    auto& cmp = dm.createComponent<Cmp1>();
    cmp.addInterface<TestService>();
    cmp.createServiceDependency<TestInterface>(TestInterface::NAME);
    cmp.build();

    char* buf = nullptr;
    size_t bufLen = 0;
    FILE* testStream = open_memstream(&buf, &bufLen);
    celix_dependencyManager_printInfo(celix_bundleContext_getDependencyManager(ctx), true, true, testStream);
    fclose(testStream);
    std::cout << buf << std::endl;
    EXPECT_TRUE(strstr(buf, "Cmp1")); //cmp name
    EXPECT_TRUE(strstr(buf, "TestService")); //provided service name
    EXPECT_TRUE(strstr(buf, "TestName")); //service dependency name
    free(buf);

    buf = nullptr;
    bufLen = 0;
    testStream = open_memstream(&buf, &bufLen);
    celix_dependencyManager_printInfo(celix_bundleContext_getDependencyManager(ctx), true, false, testStream);
    fclose(testStream);
    EXPECT_TRUE(strstr(buf, "Cmp1")); //cmp name
    EXPECT_TRUE(strstr(buf, "TestService")); //provided service name
    EXPECT_TRUE(strstr(buf, "TestName")); //service dependency name
    free(buf);

    buf = nullptr;
    bufLen = 0;
    testStream = open_memstream(&buf, &bufLen);
    celix_dependencyManager_printInfo(celix_bundleContext_getDependencyManager(ctx), false, true, testStream);
    fclose(testStream);
    EXPECT_TRUE(strstr(buf, "Cmp1")); //cmp name
    free(buf);

    buf = nullptr;
    bufLen = 0;
    testStream = open_memstream(&buf, &bufLen);
    celix_dependencyManager_printInfo(celix_bundleContext_getDependencyManager(ctx), false, false, testStream);
    fclose(testStream);
    EXPECT_TRUE(strstr(buf, "Cmp1")); //cmp name
    free(buf);

    buf = nullptr;
    bufLen = 0;
    testStream = open_memstream(&buf, &bufLen);
    celix_dependencyManager_printInfoForBundle(celix_bundleContext_getDependencyManager(ctx), true, true, 0, testStream);
    fclose(testStream);
    EXPECT_TRUE(strstr(buf, "Cmp1")); //cmp name
    free(buf);

    //bundle does not exist -> empty print
    celix_dependencyManager_printInfoForBundle(celix_bundleContext_getDependencyManager(ctx), true, true, 1 /*non existing*/, stdout);

    std::stringstream ss{};
    ss << dm;
    EXPECT_TRUE(strstr(ss.str().c_str(), "Cmp1"));

    ss = std::stringstream{};
    ss << cmp;
    EXPECT_TRUE(strstr(ss.str().c_str(), "Cmp1"));
}

TEST_F(DependencyManagerTestSuite, TestCardinality) {
    celix::dm::DependencyManager dm{ctx};
    auto& cmp1 = dm.createComponent<Cmp1>().addInterface<TestService>();
    cmp1.build();
    auto& cmp3 = dm.createComponent<Cmp3>()
                     .createServiceDependency<TestService>()
                     .setRequired(true)
                     .setMinimalCardinality(2);
    cmp3.build();

    dm.build();

    {
        auto info = dm.getInfo();
        ASSERT_EQ(info.components.size(), 2);
        auto& cmpInfo = info.components;
        auto cmpIt =
            std::find_if(cmpInfo.cbegin(), cmpInfo.cend(), [](const ComponentInfo& cmp) { return cmp.name == "Cmp3"; });
        ASSERT_TRUE(cmpIt != cmpInfo.cend());

        EXPECT_TRUE(!cmpIt->uuid.empty());
        EXPECT_EQ(cmpIt->state, "WAITING_FOR_REQUIRED");
        EXPECT_FALSE(cmpIt->isActive);
        EXPECT_EQ(cmpIt->nrOfTimesStarted, 0);
        EXPECT_EQ(cmpIt->nrOfTimesResumed, 0);

        ASSERT_EQ(cmpIt->dependenciesInfo.size(), 1);
        auto& dep = cmpIt->dependenciesInfo[0];
        EXPECT_EQ(dep.serviceName, "TestService");
        EXPECT_EQ(dep.isRequired, true);
        EXPECT_EQ(dep.isAvailable, false);
        EXPECT_EQ(dep.nrOfTrackedServices, 1);
    }

    auto& cmp2 = dm.createComponent(Cmp2{"c"}).addInterface<TestService>();
    cmp2.build();

    {
        auto info = dm.getInfo();
        ASSERT_EQ(info.components.size(), 3);
        auto& cmpInfo = info.components;
        auto cmpIt =
            std::find_if(cmpInfo.cbegin(), cmpInfo.cend(), [](const ComponentInfo& cmp) { return cmp.name == "Cmp3"; });
        ASSERT_TRUE(cmpIt != cmpInfo.cend());

        EXPECT_TRUE(!cmpIt->uuid.empty());
        EXPECT_TRUE(cmpIt->isActive);
        EXPECT_EQ(cmpIt->nrOfTimesStarted, 1);
        EXPECT_EQ(cmpIt->nrOfTimesResumed, 0);

        ASSERT_EQ(cmpIt->dependenciesInfo.size(), 1);
        auto& dep = cmpIt->dependenciesInfo[0];
        EXPECT_EQ(dep.serviceName, "TestService");
        EXPECT_EQ(dep.isRequired, true);
        EXPECT_EQ(dep.isAvailable, true);
        EXPECT_EQ(dep.nrOfTrackedServices, 2);
    }
}