mdns: Add host test using linux target

components/mdns/host_test/components/esp_timer_linux/CMakeLists.txt

@@ -0,0 +1,5 @@
+idf_component_register(SRCS esp_timer_linux.c timer_task.cpp
+                       INCLUDE_DIRS include
+                       REQUIRES esp_system_protocols_linux freertos_linux)
+
+target_compile_features(${COMPONENT_LIB} PRIVATE cxx_std_17)

components/mdns/host_test/components/esp_timer_linux/esp_timer_linux.c

@@ -0,0 +1,47 @@
+// Copyright 2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed 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 "esp_err.h"
+#include "esp_timer.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+void * create_tt(esp_timer_cb_t cb);
+
+void destroy_tt(void* tt);
+
+void set_tout(void* tt, uint32_t ms);
+
+esp_err_t esp_timer_create(const esp_timer_create_args_t* create_args,
+                           esp_timer_handle_t* out_handle)
+{
+    *out_handle = (esp_timer_handle_t)create_tt(create_args->callback);
+    return ESP_OK;
+}
+
+esp_err_t esp_timer_start_periodic(esp_timer_handle_t timer, uint64_t period)
+{
+    set_tout(timer, period/1000);
+    return ESP_OK;
+}
+
+esp_err_t esp_timer_stop(esp_timer_handle_t timer)
+{
+    return ESP_OK;
+}
+
+esp_err_t esp_timer_delete(esp_timer_handle_t timer)
+{
+    destroy_tt(timer);
+    return ESP_OK;
+}

components/mdns/host_test/components/esp_timer_linux/include/esp_timer.h

@@ -0,0 +1,41 @@
+// Copyright 2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed 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.
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef struct esp_timer* esp_timer_handle_t;
+
+typedef void (*esp_timer_cb_t)(void* arg);
+
+typedef enum {
+    ESP_TIMER_TASK,
+} esp_timer_dispatch_t;
+
+typedef struct {
+    esp_timer_cb_t callback;        //!< Function to call when timer expires
+    void* arg;                      //!< Argument to pass to the callback
+    esp_timer_dispatch_t dispatch_method;   //!< Call the callback from task or from ISR
+    const char* name;               //!< Timer name, used in esp_timer_dump function
+    bool skip_unhandled_events;     //!< Skip unhandled events for periodic timers
+} esp_timer_create_args_t;
+
+esp_err_t esp_timer_create(const esp_timer_create_args_t* create_args,
+                           esp_timer_handle_t* out_handle);
+esp_err_t esp_timer_start_periodic(esp_timer_handle_t timer, uint64_t period);
+
+esp_err_t esp_timer_stop(esp_timer_handle_t timer);
+
+esp_err_t esp_timer_delete(esp_timer_handle_t timer);

components/mdns/host_test/components/esp_timer_linux/timer_task.cpp

@@ -0,0 +1,38 @@
+// Copyright 2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed 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 "timer_task.hpp"
+#include <cstdint>
+#include <vector>
+#include <memory>
+#include <cstring>
+
+extern "C" void * create_tt(cb_t cb)
+{
+    auto * tt = new TimerTaskMock(cb);
+    return tt;
+}
+
+extern "C" void destroy_tt(void* tt)
+{
+    auto * timer_task = static_cast<TimerTaskMock *>(tt);
+    delete(timer_task);
+}
+
+
+extern "C" void set_tout(void* tt, uint32_t ms)
+{
+    auto * timer_task = static_cast<TimerTaskMock *>(tt);
+    timer_task->SetTimeout(ms);
+}

components/mdns/host_test/components/esp_timer_linux/timer_task.hpp

@@ -0,0 +1,61 @@
+// Copyright 2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed 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.
+#pragma once
+
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+#include <atomic>
+
+typedef void (*cb_t)(void* arg);
+
+class TimerTaskMock
+{
+public:
+    TimerTaskMock(cb_t cb): cb(cb), t(run_static, this), active(false), ms(INT32_MAX) {}
+    ~TimerTaskMock(void) { active = false; t.join(); }
+
+    void SetTimeout(uint32_t m)
+    {
+        ms = m;
+        active = true;
+    }
+
+private:
+
+    static void run_static(TimerTaskMock* timer)
+    {
+        timer->run();
+    }
+
+    void run(void)
+    {
+        while (!active.load()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+
+        while (active.load()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+            cb(nullptr);
+        }
+    }
+
+    cb_t cb;
+    std::thread t;
+    std::atomic<bool> active;
+    uint32_t ms;
+
+};