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
24static const char* UUID_EMPTY = "00000000-0000-0000-0000-000000000000";
25static const char* UUID_ONES = "11111111-1111-1111-1111-111111111111";
26static const char* UUID_SEQUENTIAL = "01234567-89ab-cdef-ABCD-EF0123456789";
27static const char* UUID_BASE = "00000000-0000-1000-8000-00805f9b34fb";
28
29class UuidTest : public AllocationTestHarness {
30 protected:
31  virtual void SetUp() {}
32
33  virtual void TearDown() {}
34};
35
36TEST_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
91TEST_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
105TEST_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
121TEST_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
137TEST_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