1 /* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef COMMON_UTILITIES_HPP 17 #define COMMON_UTILITIES_HPP 18 19 #include <array> 20 #include <chrono> 21 #include <string_view> 22 23 #ifdef __OHOS__ 24 #include "hilog/log.h" 25 #endif 26 27 #ifdef NDEBUG 28 #define DCHECK(cond) do { (void)sizeof(cond);} while (0) 29 #else 30 31 #include <cassert> 32 33 #define DCHECK(cond) assert((cond)) 34 #endif 35 36 namespace OHOS::uitest { 37 /**Get current time millisecond.*/ GetCurrentMillisecond()38 inline uint64_t GetCurrentMillisecond() 39 { 40 using namespace std::chrono; 41 return time_point_cast<milliseconds>(system_clock::now()).time_since_epoch().count(); 42 } 43 44 /**Get current time microseconds.*/ GetCurrentMicroseconds()45 inline uint64_t GetCurrentMicroseconds() 46 { 47 using namespace std::chrono; 48 return time_point_cast<microseconds>(system_clock::now()).time_since_epoch().count(); 49 } 50 51 // log tag length limit 52 constexpr uint8_t MAX_LOG_TAG_LEN = 64; 53 54 /**Generates log-tag by fileName and lineNumber, must be 'constexpr' to ensure the efficiency of Logger.*/ GenLogTag(std::string_view fp,std::string_view func)55 constexpr std::array<char, MAX_LOG_TAG_LEN> GenLogTag(std::string_view fp, std::string_view func) 56 { 57 constexpr uint8_t MAX_CONTENT_LEN = MAX_LOG_TAG_LEN - 1; 58 std::array<char, MAX_LOG_TAG_LEN> chars = {0}; 59 size_t pos = fp.find_last_of('/'); 60 if (pos == std::string_view::npos) { 61 pos = 0; 62 } 63 int8_t writeCursor = 0; 64 chars[writeCursor++] = '['; 65 for (size_t offSet = pos + 1; offSet < fp.length() && writeCursor < MAX_CONTENT_LEN; offSet++) { 66 chars[writeCursor++] = fp[offSet]; 67 } 68 if (writeCursor < MAX_CONTENT_LEN) { 69 chars[writeCursor++] = ':'; 70 } 71 if (writeCursor < MAX_CONTENT_LEN) { 72 chars[writeCursor++] = '('; 73 } 74 for (size_t offSet = 0; offSet < func.length() && writeCursor < MAX_CONTENT_LEN; offSet++) { 75 chars[writeCursor++] = func[offSet]; 76 } 77 if (writeCursor < MAX_CONTENT_LEN) { 78 chars[writeCursor++] = ')'; 79 } 80 if (writeCursor < MAX_CONTENT_LEN) { 81 chars[writeCursor++] = ']'; 82 } 83 // record the actual tag-length in the end byte 84 chars[MAX_CONTENT_LEN] = writeCursor; 85 return chars; 86 } 87 88 // log level 89 enum LogRank : uint8_t { 90 DEBUG = 3, INFO = 4, WARN = 5, ERROR = 6 91 }; 92 93 #ifdef __OHOS__ 94 #ifndef LOG_TAG 95 #define LOG_TAG "UiTestKit" 96 #endif 97 // print pretty log with pretty format, auto-generate tag by fileName and functionName at compile time 98 #define LOG(LEVEL, FMT, VARS...) do { \ 99 static constexpr auto tagChars= GenLogTag(__FILE__, __FUNCTION__); \ 100 static constexpr int8_t tagLen = tagChars[MAX_LOG_TAG_LEN - 1]; \ 101 if constexpr (tagLen > 0) { \ 102 auto tag = std::string_view(tagChars.data(), tagLen); \ 103 static constexpr LogType type = LogType::LOG_APP; \ 104 static constexpr uint32_t domain = 0xD001C03; \ 105 HiLogPrint(type, static_cast<LogLevel>(LEVEL), domain, LOG_TAG, "%{public}s " FMT, tag.data(), ##VARS); \ 106 } \ 107 }while (0) 108 #else 109 // nop logger 110 #define LOG(LEVEL, FMT, VARS...) do {}while (0) 111 #endif 112 113 // print debug log 114 #define LOG_D(FMT, VARS...) LOG(LogRank::DEBUG, FMT, ##VARS) 115 // print info log 116 #define LOG_I(FMT, VARS...) LOG(LogRank::INFO, FMT, ##VARS) 117 // print warning log 118 #define LOG_W(FMT, VARS...) LOG(LogRank::WARN, FMT, ##VARS) 119 // print error log 120 #define LOG_E(FMT, VARS...) LOG(LogRank::ERROR, FMT, ##VARS) 121 } 122 123 #endif