CI: fixing the files to be complient with pre-commit hooks

components/asio/examples/asio_chat/main/asio_chat.cpp

@@ -53,14 +53,15 @@ void start_client(void)
 #ifdef CONFIG_EXAMPLE_CHAT_SERVER
     std::lock_guard<std::mutex> guard(server_ready);
 #endif
-    std::thread t([&io_context]() { try {
-                                        io_context.run();
-                                  } catch (const std::exception &e) {
-                                        ESP_LOGE(TAG, "Exception occured during client thread execution %s", e.what());
-                                  }
-                                    catch (...) {
-                                         ESP_LOGE(TAG, "Unknown exception");
-                                   }});
+    std::thread t([&io_context]() {
+        try {
+            io_context.run();
+        } catch (const std::exception &e) {
+            ESP_LOGE(TAG, "Exception occured during client thread execution %s", e.what());
+        } catch (...) {
+            ESP_LOGE(TAG, "Unknown exception");
+        }
+    });
     do {
         ESP_LOGI(TAG, "CLIENT: Waiting for input");
         get_string(line, sizeof(line));
@@ -95,14 +96,14 @@ extern "C" void app_main(void)
         asio::io_context io_context;
         chat_server server(io_context, tcp::endpoint(tcp::v4(), std::atoi(CONFIG_EXAMPLE_CHAT_SERVER_BIND_PORT)));
         std::thread t =  std::thread([&io_context]() { // Chat server starting here
-                                     try {
-                                           io_context.run();
-                                     } catch (const std::exception &e) {
-                                           ESP_LOGE(TAG, "Exception occured during server thread execution %s", e.what());
-                                     }
-                                       catch (...) {
-                                           ESP_LOGE(TAG, "Unknown exception");
-                                     }});;
+            try {
+                io_context.run();
+            } catch (const std::exception &e) {
+                ESP_LOGE(TAG, "Exception occured during server thread execution %s", e.what());
+            } catch (...) {
+                ESP_LOGE(TAG, "Unknown exception");
+            }
+        });;
 #endif
 #ifdef CONFIG_EXAMPLE_CHAT_CLIENT
         start_client();

components/asio/examples/asio_chat/main/chat_message.hpp

@@ -15,77 +15,76 @@
 #include <cstdlib>
 #include <cstring>
 
-class chat_message
-{
+class chat_message {
 public:
-  static constexpr std::size_t header_length = 4;
-  static constexpr std::size_t max_body_length = 512;
+    static constexpr std::size_t header_length = 4;
+    static constexpr std::size_t max_body_length = 512;
 
-  chat_message()
-    : body_length_(0)
-  {
-  }
-
-  const char* data() const
-  {
-    return data_;
-  }
-
-  char* data()
-  {
-    return data_;
-  }
-
-  std::size_t length() const
-  {
-    return header_length + body_length_;
-  }
-
-  const char* body() const
-  {
-    return data_ + header_length;
-  }
-
-  char* body()
-  {
-    return data_ + header_length;
-  }
-
-  std::size_t body_length() const
-  {
-    return body_length_;
-  }
-
-  void body_length(std::size_t new_length)
-  {
-    body_length_ = new_length;
-    if (body_length_ > max_body_length)
-      body_length_ = max_body_length;
-  }
-
-  bool decode_header()
-  {
-    char header[header_length + 1] = "";
-    std::strncat(header, data_, header_length);
-    body_length_ = std::atoi(header);
-    if (body_length_ > max_body_length)
+    chat_message()
+        : body_length_(0)
     {
-      body_length_ = 0;
-      return false;
     }
-    return true;
-  }
 
-  void encode_header()
-  {
-    char header[header_length + 1] = "";
-    std::sprintf(header, "%4d", static_cast<int>(body_length_));
-    std::memcpy(data_, header, header_length);
-  }
+    const char *data() const
+    {
+        return data_;
+    }
+
+    char *data()
+    {
+        return data_;
+    }
+
+    std::size_t length() const
+    {
+        return header_length + body_length_;
+    }
+
+    const char *body() const
+    {
+        return data_ + header_length;
+    }
+
+    char *body()
+    {
+        return data_ + header_length;
+    }
+
+    std::size_t body_length() const
+    {
+        return body_length_;
+    }
+
+    void body_length(std::size_t new_length)
+    {
+        body_length_ = new_length;
+        if (body_length_ > max_body_length) {
+            body_length_ = max_body_length;
+        }
+    }
+
+    bool decode_header()
+    {
+        char header[header_length + 1] = "";
+        std::strncat(header, data_, header_length);
+        body_length_ = std::atoi(header);
+        if (body_length_ > max_body_length) {
+            body_length_ = 0;
+            return false;
+        }
+        return true;
+    }
+
+    void encode_header()
+    {
+        char header[header_length + 1] = "";
+        std::sprintf(header, "%4d", static_cast<int>(body_length_));
+        std::memcpy(data_, header, header_length);
+    }
 
 private:
-  char data_[header_length + max_body_length];
-  std::size_t body_length_;
+    char data_[header_length + max_body_length];
+    std::size_t body_length_;
 };
 
 #endif // CHAT_MESSAGE_HPP

components/asio/examples/asio_chat/main/client.hpp

@@ -17,107 +17,91 @@
 
 typedef std::deque<chat_message> chat_message_queue;
 
-class chat_client
-{
+class chat_client {
 public:
-  chat_client(asio::io_context& io_context,
-      const asio::ip::tcp::resolver::results_type& endpoints)
-    : io_context_(io_context),
-      socket_(io_context)
-  {
-    do_connect(endpoints);
-  }
+    chat_client(asio::io_context &io_context,
+                const asio::ip::tcp::resolver::results_type &endpoints)
+        : io_context_(io_context),
+          socket_(io_context)
+    {
+        do_connect(endpoints);
+    }
 
-  void write(const chat_message& msg)
-  {
-    asio::post(io_context_,
-        [this, msg]()
-        {
-          bool write_in_progress = !write_msgs_.empty();
-          write_msgs_.push_back(msg);
-          if (!write_in_progress)
-          {
-            do_write();
-          }
+    void write(const chat_message &msg)
+    {
+        asio::post(io_context_,
+        [this, msg]() {
+            bool write_in_progress = !write_msgs_.empty();
+            write_msgs_.push_back(msg);
+            if (!write_in_progress) {
+                do_write();
+            }
         });
-  }
+    }
 
-  void close()
-  {
-    asio::post(io_context_, [this]() { socket_.close(); });
-  }
+    void close()
+    {
+        asio::post(io_context_, [this]() {
+            socket_.close();
+        });
+    }
 
 private:
-void do_connect(const asio::ip::tcp::resolver::results_type& endpoints)
+    void do_connect(const asio::ip::tcp::resolver::results_type &endpoints)
     {
-      asio::async_connect(socket_, endpoints,
-          [this](std::error_code ec, asio::ip::tcp::endpoint)
-          {
-            if (!ec)
-            {
-              do_read_header();
+        asio::async_connect(socket_, endpoints,
+        [this](std::error_code ec, asio::ip::tcp::endpoint) {
+            if (!ec) {
+                do_read_header();
             }
-          });
+        });
     }
 
     void do_read_header()
     {
-      asio::async_read(socket_,
-          asio::buffer(read_msg_.data(), chat_message::header_length),
-          [this](std::error_code ec, std::size_t /*length*/)
-          {
-            if (!ec && read_msg_.decode_header())
-            {
-              do_read_body();
+        asio::async_read(socket_,
+                         asio::buffer(read_msg_.data(), chat_message::header_length),
+        [this](std::error_code ec, std::size_t /*length*/) {
+            if (!ec && read_msg_.decode_header()) {
+                do_read_body();
+            } else {
+                socket_.close();
             }
-            else
-            {
-              socket_.close();
-            }
-          });
+        });
     }
 
     void do_read_body()
     {
-      asio::async_read(socket_,
-          asio::buffer(read_msg_.body(), read_msg_.body_length()),
-          [this](std::error_code ec, std::size_t /*length*/)
-          {
-            if (!ec)
-            {
-              do_read_header();
+        asio::async_read(socket_,
+                         asio::buffer(read_msg_.body(), read_msg_.body_length()),
+        [this](std::error_code ec, std::size_t /*length*/) {
+            if (!ec) {
+                do_read_header();
+            } else {
+                socket_.close();
             }
-            else
-            {
-              socket_.close();
-            }
-          });
+        });
     }
 
-     void do_write()
-     {
-      asio::async_write(socket_,
-          asio::buffer(write_msgs_.front().data(),
-            write_msgs_.front().length()),
-          [this](std::error_code ec, std::size_t /*length*/)
-          {
-            if (!ec)
-            {
-              write_msgs_.pop_front();
-              if (!write_msgs_.empty())
-              {
-                do_write();
-              }
+    void do_write()
+    {
+        asio::async_write(socket_,
+                          asio::buffer(write_msgs_.front().data(),
+                                       write_msgs_.front().length()),
+        [this](std::error_code ec, std::size_t /*length*/) {
+            if (!ec) {
+                write_msgs_.pop_front();
+                if (!write_msgs_.empty()) {
+                    do_write();
+                }
+            } else {
+                socket_.close();
             }
-            else
-            {
-              socket_.close();
-            }
-          });
-      }
+        });
+    }
 
 private:
-    asio::io_context& io_context_;
+    asio::io_context &io_context_;
     asio::ip::tcp::socket socket_;
     chat_message read_msg_;
     chat_message_queue write_msgs_;

components/asio/examples/asio_chat/main/server.hpp

@@ -27,176 +27,159 @@ extern std::mutex server_ready;
 //----------------------------------------------------------------------
 
 
-class chat_participant
-{
+class chat_participant {
 public:
-  virtual ~chat_participant() {}
-  virtual void deliver(const chat_message& msg) = 0;
+    virtual ~chat_participant() {}
+    virtual void deliver(const chat_message &msg) = 0;
 };
 
 typedef std::shared_ptr<chat_participant> chat_participant_ptr;
 
 //----------------------------------------------------------------------
 
-class chat_room
-{
+class chat_room {
 public:
-  void join(chat_participant_ptr participant)
-  {
-    participants_.insert(participant);
-    for (auto msg: recent_msgs_)
-      participant->deliver(msg);
-  }
+    void join(chat_participant_ptr participant)
+    {
+        participants_.insert(participant);
+        for (auto msg : recent_msgs_) {
+            participant->deliver(msg);
+        }
+    }
 
-  void leave(chat_participant_ptr participant)
-  {
-    participants_.erase(participant);
-  }
+    void leave(chat_participant_ptr participant)
+    {
+        participants_.erase(participant);
+    }
 
-  void deliver(const chat_message& msg)
-  {
-    recent_msgs_.push_back(msg);
-    while (recent_msgs_.size() > max_recent_msgs)
-      recent_msgs_.pop_front();
+    void deliver(const chat_message &msg)
+    {
+        recent_msgs_.push_back(msg);
+        while (recent_msgs_.size() > max_recent_msgs) {
+            recent_msgs_.pop_front();
+        }
 
-    for (auto participant: participants_)
-      participant->deliver(msg);
-  }
+        for (auto participant : participants_) {
+            participant->deliver(msg);
+        }
+    }
 
 private:
-  std::set<chat_participant_ptr> participants_;
-  enum { max_recent_msgs = 100 };
-  chat_message_queue recent_msgs_;
+    std::set<chat_participant_ptr> participants_;
+    enum { max_recent_msgs = 100 };
+    chat_message_queue recent_msgs_;
 };
 
 //----------------------------------------------------------------------
 
 
 class chat_session
-  : public chat_participant,
-    public std::enable_shared_from_this<chat_session>
-{
+    : public chat_participant,
+      public std::enable_shared_from_this<chat_session> {
 public:
-  chat_session(asio::ip::tcp::socket socket, chat_room& room)
-    : socket_(std::move(socket)),
-      room_(room)
-  {
-  }
-
-  void start()
-  {
-    room_.join(shared_from_this());
-    do_read_header();
-  }
-
-  void deliver(const chat_message& msg)
-  {
-    bool write_in_progress = !write_msgs_.empty();
-    write_msgs_.push_back(msg);
-    if (!write_in_progress)
+    chat_session(asio::ip::tcp::socket socket, chat_room &room)
+        : socket_(std::move(socket)),
+          room_(room)
     {
-      do_write();
     }
-  }
+
+    void start()
+    {
+        room_.join(shared_from_this());
+        do_read_header();
+    }
+
+    void deliver(const chat_message &msg)
+    {
+        bool write_in_progress = !write_msgs_.empty();
+        write_msgs_.push_back(msg);
+        if (!write_in_progress) {
+            do_write();
+        }
+    }
 
 private:
-  void do_read_header()
-  {
-    auto self(shared_from_this());
-    asio::async_read(socket_,
-        asio::buffer(read_msg_.data(), chat_message::header_length),
-        [this, self](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec && read_msg_.decode_header())
-          {
-            do_read_body();
-          }
-          else
-          {
-            room_.leave(shared_from_this());
-          }
-         });
-   }
+    void do_read_header()
+    {
+        auto self(shared_from_this());
+        asio::async_read(socket_,
+                         asio::buffer(read_msg_.data(), chat_message::header_length),
+        [this, self](std::error_code ec, std::size_t /*length*/) {
+            if (!ec && read_msg_.decode_header()) {
+                do_read_body();
+            } else {
+                room_.leave(shared_from_this());
+            }
+        });
+    }
 
-   void do_read_body()
-   {
-     auto self(shared_from_this());
-     asio::async_read(socket_,
-         asio::buffer(read_msg_.body(), read_msg_.body_length()),
-         [this, self](std::error_code ec, std::size_t /*length*/)
-         {
-           if (!ec)
-           {
-             ESP_LOGD("asio-chat:", "%s", read_msg_.body());
-             room_.deliver(read_msg_);
-             do_read_header();
-           }
-           else
-           {
-             room_.leave(shared_from_this());
-           }
-         });
-   }
+    void do_read_body()
+    {
+        auto self(shared_from_this());
+        asio::async_read(socket_,
+                         asio::buffer(read_msg_.body(), read_msg_.body_length()),
+        [this, self](std::error_code ec, std::size_t /*length*/) {
+            if (!ec) {
+                ESP_LOGD("asio-chat:", "%s", read_msg_.body());
+                room_.deliver(read_msg_);
+                do_read_header();
+            } else {
+                room_.leave(shared_from_this());
+            }
+        });
+    }
 
-   void do_write()
-   {
-     auto self(shared_from_this());
-     asio::async_write(socket_,
-         asio::buffer(write_msgs_.front().data(),
-           write_msgs_.front().length()),
-         [this, self](std::error_code ec, std::size_t /*length*/)
-         {
-           if (!ec)
-           {
-             write_msgs_.pop_front();
-             if (!write_msgs_.empty())
-             {
-               do_write();
-             }
-           }
-           else
-           {
-             room_.leave(shared_from_this());
-           }
-         });
-   }
+    void do_write()
+    {
+        auto self(shared_from_this());
+        asio::async_write(socket_,
+                          asio::buffer(write_msgs_.front().data(),
+                                       write_msgs_.front().length()),
+        [this, self](std::error_code ec, std::size_t /*length*/) {
+            if (!ec) {
+                write_msgs_.pop_front();
+                if (!write_msgs_.empty()) {
+                    do_write();
+                }
+            } else {
+                room_.leave(shared_from_this());
+            }
+        });
+    }
 
-   asio::ip::tcp::socket socket_;
-   chat_room& room_;
-   chat_message read_msg_;
-   chat_message_queue write_msgs_;
- };
+    asio::ip::tcp::socket socket_;
+    chat_room &room_;
+    chat_message read_msg_;
+    chat_message_queue write_msgs_;
+};
 
 //----------------------------------------------------------------------
 
-class chat_server
-{
+class chat_server {
 public:
-  chat_server(asio::io_context& io_context,
-      const asio::ip::tcp::endpoint& endpoint)
-    : acceptor_(io_context, endpoint)
-  {
-    do_accept();
-  }
+    chat_server(asio::io_context &io_context,
+                const asio::ip::tcp::endpoint &endpoint)
+        : acceptor_(io_context, endpoint)
+    {
+        do_accept();
+    }
 
 private:
-  void do_accept()
-  {
-    std::lock_guard<std::mutex> guard(server_ready);
-    acceptor_.async_accept(
-       [this](std::error_code ec, asio::ip::tcp::socket socket)
-       {
-         if (!ec)
-         {
-           std::make_shared<chat_session>(std::move(socket), room_)->start();
-         }
+    void do_accept()
+    {
+        std::lock_guard<std::mutex> guard(server_ready);
+        acceptor_.async_accept(
+        [this](std::error_code ec, asio::ip::tcp::socket socket) {
+            if (!ec) {
+                std::make_shared<chat_session>(std::move(socket), room_)->start();
+            }
 
-         do_accept();
-       });
-  }
+            do_accept();
+        });
+    }
 
-  asio::ip::tcp::acceptor acceptor_;
-  chat_room room_;
+    asio::ip::tcp::acceptor acceptor_;
+    chat_room room_;
 };
 
 #endif // CHAT_SERVER_HPP

components/asio/examples/asio_chat/pytest_asio_chat_test.py

@@ -1,14 +1,9 @@
-# This example code is in the Public Domain (or CC0 licensed, at your option.)
-
-# Unless required by applicable law or agreed to in writing, this
-# software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-# CONDITIONS OF ANY KIND, either express or implied.
+# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
 
 # -*- coding: utf-8 -*-
 
 import re
-import pytest
-from pytest_embedded import Dut
 
 
 def test_examples_asio_chat(dut):