1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "utils.h"
18 #include "stl_util.h"
19
20 #include "gmock/gmock.h"
21 #include "gtest/gtest.h"
22
23 namespace art {
24
25 class UtilsTest : public ::testing::Test {};
26
TEST_F(UtilsTest,PrettySize)27 TEST_F(UtilsTest, PrettySize) {
28 EXPECT_EQ("1024MB", PrettySize(1 * GB));
29 EXPECT_EQ("2048MB", PrettySize(2 * GB));
30 if (sizeof(size_t) > sizeof(uint32_t)) {
31 EXPECT_EQ("100GB", PrettySize(100 * GB));
32 }
33 EXPECT_EQ("1024KB", PrettySize(1 * MB));
34 EXPECT_EQ("10MB", PrettySize(10 * MB));
35 EXPECT_EQ("100MB", PrettySize(100 * MB));
36 EXPECT_EQ("1024B", PrettySize(1 * KB));
37 EXPECT_EQ("10KB", PrettySize(10 * KB));
38 EXPECT_EQ("100KB", PrettySize(100 * KB));
39 EXPECT_EQ("0B", PrettySize(0));
40 EXPECT_EQ("1B", PrettySize(1));
41 EXPECT_EQ("10B", PrettySize(10));
42 EXPECT_EQ("100B", PrettySize(100));
43 EXPECT_EQ("512B", PrettySize(512));
44 }
45
Split(const char * arr,char s,std::vector<std::string_view> * sv)46 void Split(const char* arr, char s, std::vector<std::string_view>* sv) {
47 Split<std::string_view>(std::string_view(arr), s, sv);
48 }
49
TEST_F(UtilsTest,Split)50 TEST_F(UtilsTest, Split) {
51 std::vector<std::string_view> actual;
52 std::vector<std::string_view> expected;
53
54 expected.clear();
55
56 actual.clear();
57 Split("", ':', &actual);
58 EXPECT_EQ(expected, actual);
59
60 actual.clear();
61 Split(":", ':', &actual);
62 EXPECT_EQ(expected, actual);
63
64 expected.clear();
65 expected.push_back("foo");
66
67 actual.clear();
68 Split(":foo", ':', &actual);
69 EXPECT_EQ(expected, actual);
70
71 actual.clear();
72 Split("foo:", ':', &actual);
73 EXPECT_EQ(expected, actual);
74
75 actual.clear();
76 Split(":foo:", ':', &actual);
77 EXPECT_EQ(expected, actual);
78
79 expected.push_back("bar");
80
81 actual.clear();
82 Split("foo:bar", ':', &actual);
83 EXPECT_EQ(expected, actual);
84
85 actual.clear();
86 Split(":foo:bar", ':', &actual);
87 EXPECT_EQ(expected, actual);
88
89 actual.clear();
90 Split("foo:bar:", ':', &actual);
91 EXPECT_EQ(expected, actual);
92
93 actual.clear();
94 Split(":foo:bar:", ':', &actual);
95 EXPECT_EQ(expected, actual);
96
97 expected.push_back("baz");
98
99 actual.clear();
100 Split("foo:bar:baz", ':', &actual);
101 EXPECT_EQ(expected, actual);
102
103 actual.clear();
104 Split(":foo:bar:baz", ':', &actual);
105 EXPECT_EQ(expected, actual);
106
107 actual.clear();
108 Split("foo:bar:baz:", ':', &actual);
109 EXPECT_EQ(expected, actual);
110
111 actual.clear();
112 Split(":foo:bar:baz:", ':', &actual);
113 EXPECT_EQ(expected, actual);
114 }
115
TEST_F(UtilsTest,GetProcessStatus)116 TEST_F(UtilsTest, GetProcessStatus) {
117 EXPECT_THAT(
118 GetProcessStatus("Name"),
119 ::testing::AnyOf("art_libartbase_", // Test binary name: `art_libartbase_test`.
120 "art_standalone_")); // Test binary name: `art_standalone_libartbase_test`.
121 EXPECT_EQ("R (running)", GetProcessStatus("State"));
122 EXPECT_EQ("<unknown>", GetProcessStatus("tate"));
123 EXPECT_EQ("<unknown>", GetProcessStatus("e"));
124 EXPECT_EQ("<unknown>", GetProcessStatus("InvalidFieldName"));
125 }
126
TEST_F(UtilsTest,GetOsThreadStatQuick)127 TEST_F(UtilsTest, GetOsThreadStatQuick) {
128 std::string my_stat = GetOsThreadStatQuick(GetTid());
129 EXPECT_GT(my_stat.length(), 20);
130 EXPECT_LT(my_stat.length(), 1000);
131 EXPECT_EQ('R', GetStateFromStatString(my_stat));
132 }
133
TEST_F(UtilsTest,StringSplit)134 TEST_F(UtilsTest, StringSplit) {
135 auto range = SplitString("[ab[c[[d[e[", '[');
136 auto it = range.begin();
137 EXPECT_FALSE(it == range.end());
138 EXPECT_EQ(*it++, "");
139 EXPECT_FALSE(it == range.end());
140 EXPECT_EQ(*it++, "ab");
141 EXPECT_FALSE(it == range.end());
142 EXPECT_EQ(*it++, "c");
143 EXPECT_FALSE(it == range.end());
144 EXPECT_EQ(*it++, "");
145 EXPECT_FALSE(it == range.end());
146 EXPECT_EQ(*it++, "d");
147 EXPECT_FALSE(it == range.end());
148 EXPECT_EQ(*it++, "e");
149 EXPECT_FALSE(it == range.end());
150 EXPECT_EQ(*it++, "");
151 EXPECT_TRUE(it == range.end());
152 }
153
TEST_F(UtilsTest,StringSplit2)154 TEST_F(UtilsTest, StringSplit2) {
155 auto range = SplitString("ab[c[[d[e", '[');
156 auto it = range.begin();
157 EXPECT_FALSE(it == range.end());
158 EXPECT_EQ(*it++, "ab");
159 EXPECT_FALSE(it == range.end());
160 EXPECT_EQ(*it++, "c");
161 EXPECT_FALSE(it == range.end());
162 EXPECT_EQ(*it++, "");
163 EXPECT_FALSE(it == range.end());
164 EXPECT_EQ(*it++, "d");
165 EXPECT_FALSE(it == range.end());
166 EXPECT_EQ(*it++, "e");
167 EXPECT_TRUE(it == range.end());
168 }
169
TEST_F(UtilsTest,StringSplit3)170 TEST_F(UtilsTest, StringSplit3) {
171 auto range = SplitString("", '[');
172 auto it = range.begin();
173 EXPECT_FALSE(it == range.end());
174 EXPECT_EQ(*it++, "");
175 EXPECT_TRUE(it == range.end());
176 }
177
178 } // namespace art
179