1 /******************************************************************************
2 *
3 * Copyright (C) 2014 Google, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 #include <gtest/gtest.h>
20 #include "osi/test/AllocationTestHarness.h"
21
22 #include "btcore/include/uuid.h"
23
24 static const char* UUID_EMPTY = "00000000-0000-0000-0000-000000000000";
25 static const char* UUID_ONES = "11111111-1111-1111-1111-111111111111";
26 static const char* UUID_SEQUENTIAL = "01234567-89ab-cdef-ABCD-EF0123456789";
27 static const char* UUID_BASE = "00000000-0000-1000-8000-00805f9b34fb";
28
29 class UuidTest : public AllocationTestHarness {
30 protected:
SetUp()31 virtual void SetUp() {}
32
TearDown()33 virtual void TearDown() {}
34 };
35
TEST_F(UuidTest,new_from_string)36 TEST_F(UuidTest, new_from_string) {
37 bt_uuid_t* uuid;
38
39 uuid = uuid_new("incorrect length");
40 EXPECT_EQ(NULL, uuid);
41
42 uuid = uuid_new("correct length but missing dashes --");
43 EXPECT_EQ(NULL, uuid);
44
45 uuid = uuid_new(UUID_ONES);
46 ASSERT_TRUE(uuid != NULL);
47 for (int i = 0; i < 16; i++) {
48 EXPECT_EQ(0x11, uuid->uu[i]);
49 }
50 uuid_free(uuid);
51
52 uuid = uuid_new(UUID_SEQUENTIAL);
53 EXPECT_EQ(0x01, uuid->uu[0]);
54 EXPECT_EQ(0x23, uuid->uu[1]);
55 EXPECT_EQ(0x45, uuid->uu[2]);
56 EXPECT_EQ(0x67, uuid->uu[3]);
57 EXPECT_EQ(0x89, uuid->uu[4]);
58 EXPECT_EQ(0xAB, uuid->uu[5]);
59 EXPECT_EQ(0xCD, uuid->uu[6]);
60 EXPECT_EQ(0xEF, uuid->uu[7]);
61 EXPECT_EQ(0xab, uuid->uu[8]);
62 EXPECT_EQ(0xcd, uuid->uu[9]);
63 EXPECT_EQ(0xef, uuid->uu[10]);
64 EXPECT_EQ(0x01, uuid->uu[11]);
65 EXPECT_EQ(0x23, uuid->uu[12]);
66 EXPECT_EQ(0x45, uuid->uu[13]);
67 EXPECT_EQ(0x67, uuid->uu[14]);
68 EXPECT_EQ(0x89, uuid->uu[15]);
69 uuid_free(uuid);
70
71 uuid = uuid_new(UUID_BASE);
72 EXPECT_EQ(0x00, uuid->uu[0]);
73 EXPECT_EQ(0x00, uuid->uu[1]);
74 EXPECT_EQ(0x00, uuid->uu[2]);
75 EXPECT_EQ(0x00, uuid->uu[3]);
76 EXPECT_EQ(0x00, uuid->uu[4]);
77 EXPECT_EQ(0x00, uuid->uu[5]);
78 EXPECT_EQ(0x10, uuid->uu[6]);
79 EXPECT_EQ(0x00, uuid->uu[7]);
80 EXPECT_EQ(0x80, uuid->uu[8]);
81 EXPECT_EQ(0x00, uuid->uu[9]);
82 EXPECT_EQ(0x00, uuid->uu[10]);
83 EXPECT_EQ(0x80, uuid->uu[11]);
84 EXPECT_EQ(0x5f, uuid->uu[12]);
85 EXPECT_EQ(0x9b, uuid->uu[13]);
86 EXPECT_EQ(0x34, uuid->uu[14]);
87 EXPECT_EQ(0xfb, uuid->uu[15]);
88 uuid_free(uuid);
89 }
90
TEST_F(UuidTest,uuid_is_empty)91 TEST_F(UuidTest, uuid_is_empty) {
92 bt_uuid_t* uuid = NULL;
93
94 uuid = uuid_new(UUID_EMPTY);
95 ASSERT_TRUE(uuid != NULL);
96 EXPECT_TRUE(uuid_is_empty(uuid));
97 uuid_free(uuid);
98
99 uuid = uuid_new(UUID_BASE);
100 ASSERT_TRUE(uuid != NULL);
101 EXPECT_FALSE(uuid_is_empty(uuid));
102 uuid_free(uuid);
103 }
104
TEST_F(UuidTest,uuid_128_to_16)105 TEST_F(UuidTest, uuid_128_to_16) {
106 bt_uuid_t* uuid = NULL;
107 uint16_t uuid16 = 0xffff;
108
109 uuid = uuid_new(UUID_ONES);
110 EXPECT_FALSE(uuid_128_to_16(uuid, &uuid16));
111 uuid_free(uuid);
112 EXPECT_EQ((uint16_t)0xffff, uuid16);
113
114 uuid = uuid_new(UUID_BASE);
115 EXPECT_TRUE(uuid_128_to_16(uuid, &uuid16));
116 uuid_free(uuid);
117 EXPECT_NE((uint16_t)0xffff, uuid16);
118 EXPECT_EQ((uint16_t)0, uuid16);
119 }
120
TEST_F(UuidTest,uuid_128_to_32)121 TEST_F(UuidTest, uuid_128_to_32) {
122 bt_uuid_t* uuid = NULL;
123 uint32_t uuid32 = 0xffffffff;
124
125 uuid = uuid_new(UUID_ONES);
126 EXPECT_FALSE(uuid_128_to_32(uuid, &uuid32));
127 uuid_free(uuid);
128 EXPECT_EQ((uint32_t)0xffffffff, uuid32);
129
130 uuid = uuid_new(UUID_BASE);
131 EXPECT_TRUE(uuid_128_to_32(uuid, &uuid32));
132 uuid_free(uuid);
133 EXPECT_NE((uint32_t)0xffffffff, uuid32);
134 EXPECT_EQ((uint32_t)0, uuid32);
135 }
136
TEST_F(UuidTest,uuid_to_string)137 TEST_F(UuidTest, uuid_to_string) {
138 bt_uuid_t* uuid = NULL;
139
140 uuid_string_t* uuid_string = uuid_string_new();
141 EXPECT_TRUE(uuid_string != NULL);
142
143 uuid = uuid_new(UUID_BASE);
144 EXPECT_TRUE(uuid != NULL);
145 uuid_to_string(uuid, uuid_string);
146 uuid_free(uuid);
147
148 EXPECT_TRUE(!strcmp(UUID_BASE, uuid_string_data(uuid_string)));
149
150 uuid = uuid_new(UUID_SEQUENTIAL);
151 EXPECT_TRUE(uuid != NULL);
152
153 uuid_to_string(uuid, uuid_string);
154 uuid_free(uuid);
155
156 char lower_case_buf[36 + 1];
157 for (int i = 0; i < 36 + 1; i++) {
158 lower_case_buf[i] = tolower(UUID_SEQUENTIAL[i]);
159 }
160 EXPECT_TRUE(!strcmp(lower_case_buf, uuid_string_data(uuid_string)));
161 uuid_string_free(uuid_string);
162 }
163