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(GetProcessStatus("Name"),
118 testing::AnyOf(
119 "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,StringSplit)127 TEST_F(UtilsTest, StringSplit) {
128 auto range = SplitString("[ab[c[[d[e[", '[');
129 auto it = range.begin();
130 EXPECT_FALSE(it == range.end());
131 EXPECT_EQ(*it++, "");
132 EXPECT_FALSE(it == range.end());
133 EXPECT_EQ(*it++, "ab");
134 EXPECT_FALSE(it == range.end());
135 EXPECT_EQ(*it++, "c");
136 EXPECT_FALSE(it == range.end());
137 EXPECT_EQ(*it++, "");
138 EXPECT_FALSE(it == range.end());
139 EXPECT_EQ(*it++, "d");
140 EXPECT_FALSE(it == range.end());
141 EXPECT_EQ(*it++, "e");
142 EXPECT_FALSE(it == range.end());
143 EXPECT_EQ(*it++, "");
144 EXPECT_TRUE(it == range.end());
145 }
146
TEST_F(UtilsTest,StringSplit2)147 TEST_F(UtilsTest, StringSplit2) {
148 auto range = SplitString("ab[c[[d[e", '[');
149 auto it = range.begin();
150 EXPECT_FALSE(it == range.end());
151 EXPECT_EQ(*it++, "ab");
152 EXPECT_FALSE(it == range.end());
153 EXPECT_EQ(*it++, "c");
154 EXPECT_FALSE(it == range.end());
155 EXPECT_EQ(*it++, "");
156 EXPECT_FALSE(it == range.end());
157 EXPECT_EQ(*it++, "d");
158 EXPECT_FALSE(it == range.end());
159 EXPECT_EQ(*it++, "e");
160 EXPECT_TRUE(it == range.end());
161 }
162
TEST_F(UtilsTest,StringSplit3)163 TEST_F(UtilsTest, StringSplit3) {
164 auto range = SplitString("", '[');
165 auto it = range.begin();
166 EXPECT_FALSE(it == range.end());
167 EXPECT_EQ(*it++, "");
168 EXPECT_TRUE(it == range.end());
169 }
170
171 } // namespace art
172