archives/pebble
2
0
Fork 0
mirror of https://github.com/google/pebble.git synced 2025-07-10 00:20:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Import of the watch repository from Pebble

Browse source
This commit is contained in:
Matthieu Jeanson 2024-12-12 16:43:03 -08:00 • committed by Katharine Berry
commit 3b92768480
10334 changed files with 2564465 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

568
tests/fw/services/blob_db/test_app_glance_db.c Normal file
View file

@ -0,0 +1,568 @@
/*
* Copyright 2024 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "clar.h"
#include "applib/app_glance.h"
#include "drivers/rtc.h"
#include "kernel/pbl_malloc.h"
#include "resource/resource_ids.auto.h"
#include "services/normal/app_glances/app_glance_service.h"
#include "services/normal/blob_db/app_glance_db.h"
#include "services/normal/blob_db/app_glance_db_private.h"
#include "services/normal/filesystem/pfs.h"
#include "util/uuid.h"
// Fakes
////////////////////////////////////////////////////////////////
#include "fake_settings_file.h"
#include "fake_events.h"
// Stubs
////////////////////////////////////////////////////////////////
#include "stubs_logging.h"
#include "stubs_mutex.h"
#include "stubs_passert.h"
#include "stubs_pbl_malloc.h"
status_t pfs_remove(const char *name) {
fake_settings_file_reset();
return S_SUCCESS;
}
static bool s_app_cache_entry_exists = true;
bool app_cache_entry_exists(AppInstallId app_id) {
return s_app_cache_entry_exists;
}
static int s_launch_count = 0;
status_t app_cache_app_launched(AppInstallId app_id) {
s_launch_count++;
return S_SUCCESS;
}
static AppInstallId s_app_install_id = 1;
AppInstallId app_install_get_id_for_uuid(const Uuid *uuid) {
if (!uuid) {
return INSTALL_ID_INVALID;
}
return s_app_install_id;
}
bool app_install_id_from_system(AppInstallId id) {
return (id < INSTALL_ID_INVALID);
}
bool app_install_id_from_app_db(AppInstallId id) {
return (id > INSTALL_ID_INVALID);
}
#define APP_GLANCE_TEST_UUID \
(UuidMake(0x3d, 0xc6, 0xb9, 0x4c, 0x4, 0x2, 0x48, 0xf4, \
0xbe, 0x14, 0x81, 0x17, 0xf1, 0xa, 0xa9, 0xc4))
static const uint8_t s_app_glance_basic[] = {
// Version
APP_GLANCE_DB_CURRENT_VERSION,
// Creation time
0x14, 0x13, 0x4E, 0x57, // 1464734484 (Tue, 31 May 2016 22:41:24 GMT)
// Slice 1
0x22, 0x00, // Total size
0x00, // AppGlanceSliceType - AppGlanceSliceType_IconAndSubtitle
0x03, // Number of attributes
// Slice Attributes
0x25, // Attribute ID - AttributeIdTimestamp
0x04, 0x00, // Attribute Length
// Slice expiration time:
0x94, 0x64, 0x4F, 0x57, // 1464820884 (Wed, 1 June 2016 22:41:24 GMT)
0x30, // Attribute ID - AttributeIdIcon
0x04, 0x00, // Attribute Length
// Slice icon resource ID:
0x69, 0x00, 0x00, 0x00, //
0x2F, // Attribute ID - AttributeIdSubtitleTemplateString
0x0D, 0x00, // Attribute Length
// Slice subtitle:
'T', 'e', 's', 't', ' ', 's', 'u', 'b', 't', 'i', 't', 'l', 'e',
};
// Note that `APP_GLANCE_DB_MAX_SLICES_PER_GLANCE` is reduced for the unit tests!
static const uint8_t s_app_glance_with_too_many_slices[] = {
// Version
APP_GLANCE_DB_CURRENT_VERSION,
// Creation time
0x14, 0x13, 0x4E, 0x57, // 1464734484 (Tue, 31 May 2016 22:41:24 GMT)
// Slice 1
0x0B, 0x00, // Total size
0x00, // AppGlanceSliceType - AppGlanceSliceType_IconAndSubtitle
0x01, // Number of attributes
// Slice Attributes
0x25, // Attribute ID - AttributeIdTimestamp
0x04, 0x00, // Attribute Length
// Slice expiration time:
0x94, 0x64, 0x4F, 0x57, // 1464820884 (Wed, 1 June 2016 22:41:24 GMT)
// Slice 2
0x0B, 0x00, // Total size
0x00, // AppGlanceSliceType - AppGlanceSliceType_IconAndSubtitle
0x01, // Number of attributes
// Slice Attributes
0x25, // Attribute ID - AttributeIdTimestamp
0x04, 0x00, // Attribute Length
// Slice expiration time:
0x95, 0x64, 0x4F, 0x57, // 1464820884 (Wed, 1 June 2016 22:41:25 GMT)
// Slice 3
0x0B, 0x00, // Total size
0x00, // AppGlanceSliceType - AppGlanceSliceType_IconAndSubtitle
0x01, // Number of attributes
// Slice Attributes
0x25, // Attribute ID - AttributeIdTimestamp
0x04, 0x00, // Attribute Length
// Slice expiration time:
0x96, 0x64, 0x4F, 0x57, // 1464820884 (Wed, 1 June 2016 22:41:26 GMT)
};
static const uint8_t s_app_glance_with_invalid_slice_total_sizes[] = {
// Version
APP_GLANCE_DB_CURRENT_VERSION,
// Creation time
0x14, 0x13, 0x4E, 0x57, // 1464734484 (Tue, 31 May 2016 22:41:24 GMT)
// Slice 1 (valid)
0x0B, 0x00, // Total size
0x00, // AppGlanceSliceType - AppGlanceSliceType_IconAndSubtitle
0x01, // Number of attributes
// Slice Attributes
0x25, // Attribute ID - AttributeIdTimestamp
0x04, 0x00, // Attribute Length
// Slice expiration time:
0x94, 0x64, 0x4F, 0x57, // 1464820884 (Wed, 1 June 2016 22:41:24 GMT)
// Slice 2 (invalid total_size)
0xFF, 0x00, // Total size
0x00, // AppGlanceSliceType - AppGlanceSliceType_IconAndSubtitle
0x01, // Number of attributes
// Slice Attributes
0x25, // Attribute ID - AttributeIdTimestamp
0x04, 0x00, // Attribute Length
// Slice expiration time:
0x95, 0x64, 0x4F, 0x57, // 1464820884 (Wed, 1 June 2016 22:41:25 GMT)
};
// Setup
////////////////////////////////////////////////////////////////
void test_app_glance_db__initialize(void) {
s_app_cache_entry_exists = true;
s_app_install_id = 1;
s_launch_count = 0;
fake_event_init();
fake_settings_file_reset();
app_glance_db_init();
}
void app_glance_db_deinit(void);
void test_app_glance_db__cleanup(void) {
app_glance_db_deinit();
}
// Blob Tests
////////////////////////////////////////////////////////////////
void test_app_glance_db__blob_insertion_with_invalid_key_or_val_length_fails(void) {
// Invalid key length should fail
const size_t invalid_key_length = 1337;
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, invalid_key_length,
(uint8_t *)&s_app_glance_basic,
sizeof(s_app_glance_basic)),
E_INVALID_ARGUMENT);
// Invalid val length should fail
const size_t invalid_val_size = sizeof(SerializedAppGlanceHeader) - 1;
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&s_app_glance_basic, invalid_val_size),
E_INVALID_ARGUMENT);
}
void test_app_glance_db__basic_glance_blob_insert_and_read(void) {
const size_t glance_size = sizeof(s_app_glance_basic);
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&s_app_glance_basic, glance_size),
S_SUCCESS);
cl_assert_equal_i(app_glance_db_get_len((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE),
glance_size);
uint8_t *glance_out = kernel_malloc(glance_size);
cl_assert_equal_i(app_glance_db_read((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE, glance_out,
glance_size),
S_SUCCESS);
cl_assert_equal_m(glance_out, (uint8_t *)s_app_glance_basic, glance_size);
kernel_free(glance_out);
}
void test_app_glance_db__blob_read_with_invalid_key_length_or_null_val_out_fails(void) {
// Call the basic glance blob insert test to insert the basic glance blob
test_app_glance_db__basic_glance_blob_insert_and_read();
const size_t glance_size = sizeof(s_app_glance_basic);
uint8_t glance_out[glance_size];
// Trying to read the basic glance blob back with an invalid key length should fail
const size_t invalid_key_length = 1337;
cl_assert_equal_i(app_glance_db_read((uint8_t *)&APP_GLANCE_TEST_UUID, invalid_key_length,
glance_out, glance_size),
E_INVALID_ARGUMENT);
// Trying to read the basic glance blob back with a NULL glance_out argument should fail
uint8_t *invalid_glance_out = NULL;
cl_assert_equal_i(app_glance_db_read((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
invalid_glance_out, glance_size),
E_INVALID_ARGUMENT);
}
void test_app_glance_db__basic_glance_blob_delete(void) {
// Call the basic glance blob insert test to insert the basic glance blob
test_app_glance_db__basic_glance_blob_insert_and_read();
// Delete the basic glance blob
cl_assert_equal_i(app_glance_db_delete((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE),
S_SUCCESS);
const size_t glance_size = sizeof(s_app_glance_basic);
uint8_t glance_out[glance_size];
// Trying to read the basic glance blob now should fail because it should no longer exist
cl_assert_equal_i(app_glance_db_read((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE, glance_out,
glance_size),
E_DOES_NOT_EXIST);
}
void test_app_glance_db__delete_non_existing_blob_does_nothing(void) {
// Trying to delete a glance that is not actually in the database should do nothing
cl_assert_equal_i(app_glance_db_delete((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE),
S_SUCCESS);
}
void test_app_glance_db__delete_blob_with_invalid_key_length_fails(void) {
// Call the basic glance blob insert test to insert the basic glance blob
test_app_glance_db__basic_glance_blob_insert_and_read();
// Trying to delete the basic glance blob with an invalid key length should fail
const size_t invalid_key_length = 1337;
cl_assert_equal_i(app_glance_db_delete((uint8_t *)&APP_GLANCE_TEST_UUID, invalid_key_length),
E_INVALID_ARGUMENT);
}
void test_app_glance_db__glance_blob_with_older_creation_time_than_existing_not_inserted(void) {
// Insert the first glance blob
SerializedAppGlanceHeader app_glance_1 = (SerializedAppGlanceHeader) {
.version = APP_GLANCE_DB_CURRENT_VERSION,
.creation_time = 1464734484, // Tue, 31 May 2016 22:41:24 GMT
};
const size_t glance_1_size = sizeof(app_glance_1);
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&app_glance_1, glance_1_size),
S_SUCCESS);
cl_assert_equal_i(app_glance_db_get_len((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE),
glance_1_size);
// Try to insert a different glance blob with an older creation time; this should fail
SerializedAppGlanceHeader app_glance_2 = (SerializedAppGlanceHeader) {
.version = APP_GLANCE_DB_CURRENT_VERSION,
.creation_time = 1464648084, // Mon, 30 May 2016 22:41:24 GMT
};
const size_t glance_2_size = sizeof(app_glance_2);
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&app_glance_2, glance_2_size),
E_INVALID_ARGUMENT);
}
void test_app_glance_db__glance_blob_with_too_many_slices_inserted_but_trimmed(void) {
const size_t original_glance_size = sizeof(s_app_glance_with_too_many_slices);
const size_t excess_slices_size = 11;
const size_t trimmed_glance_size = original_glance_size - excess_slices_size;
// Insert the glance blob with too many slices; this should succeed
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&s_app_glance_with_too_many_slices,
original_glance_size),
S_SUCCESS);
// But the length we read back should be trimmed of the excess slices
cl_assert_equal_i(app_glance_db_get_len((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE),
trimmed_glance_size);
// The glance blob read back from the database should match everything up to where we trimmed
uint8_t glance_out[trimmed_glance_size];
cl_assert_equal_i(app_glance_db_read((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE, glance_out,
trimmed_glance_size),
S_SUCCESS);
cl_assert_equal_m(glance_out, (uint8_t *)s_app_glance_with_too_many_slices, trimmed_glance_size);
}
static void prv_check_invalid_version_code_blob_not_inserted(uint8_t version) {
const SerializedAppGlanceHeader app_glance = (SerializedAppGlanceHeader) {
.version = version,
};
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&app_glance, sizeof(app_glance)),
E_INVALID_ARGUMENT);
}
void test_app_glance_db__lower_version_blob_not_inserted(void) {
for (uint8_t version = 0; version < APP_GLANCE_DB_CURRENT_VERSION; version++) {
prv_check_invalid_version_code_blob_not_inserted(version);
}
}
void test_app_glance_db__higher_version_not_blob_inserted(void) {
prv_check_invalid_version_code_blob_not_inserted(APP_GLANCE_DB_CURRENT_VERSION + 1);
}
static status_t prv_insert_dummy_glance_blob_with_size(uint16_t blob_size) {
const uint8_t dummy_app_glance[] = {
// Version
APP_GLANCE_DB_CURRENT_VERSION,
// Creation time
0x14, 0x13, 0x4E, 0x57, // 1464734484 (Tue, 31 May 2016 22:41:24 GMT)
// Slice 1
(uint8_t)(blob_size & 0xFF), (uint8_t)(blob_size >> 8), // Total size
};
return app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&dummy_app_glance, sizeof(dummy_app_glance));
}
void test_app_glance_db__check_too_small_blob_not_inserted(void) {
cl_assert_equal_i(prv_insert_dummy_glance_blob_with_size(APP_GLANCE_DB_SLICE_MIN_SIZE - 1),
E_INVALID_ARGUMENT);
}
void test_app_glance_db__check_too_large_blob_not_inserted(void) {
cl_assert_equal_i(prv_insert_dummy_glance_blob_with_size(APP_GLANCE_DB_SLICE_MAX_SIZE + 1),
E_INVALID_ARGUMENT);
}
void test_app_glance_db__check_invalid_slice_total_sizes_blob_not_inserted(void) {
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&s_app_glance_with_invalid_slice_total_sizes,
sizeof(s_app_glance_with_invalid_slice_total_sizes)),
E_INVALID_ARGUMENT);
}
status_t app_glance_db_insert_stale(const uint8_t *key, int key_len, const uint8_t *val,
int val_len);
void test_app_glance_db__read_stale_glance_blob(void) {
// Force the insertion of a stale glance blob (outdated version)
const SerializedAppGlanceHeader app_glance = (SerializedAppGlanceHeader) {
.version = APP_GLANCE_DB_CURRENT_VERSION - 1,
};
cl_assert_equal_i(app_glance_db_insert_stale((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&app_glance, sizeof(app_glance)),
S_SUCCESS);
// Verify that trying to read the blob back fails due to it not existing
SerializedAppGlanceHeader glance_out = {};
cl_assert_equal_i(app_glance_db_read((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&glance_out, sizeof(SerializedAppGlanceHeader)),
E_DOES_NOT_EXIST);
}
void test_app_glance_db__glance_blob_with_slice_missing_expiration_time_gets_default_value(void) {
const uint8_t app_glance_with_slice_missing_expiration_time[] = {
// Version
APP_GLANCE_DB_CURRENT_VERSION,
// Creation time
0x14, 0x13, 0x4E, 0x57, // 1464734484 (Tue, 31 May 2016 22:41:24 GMT)
// Slice 1
0x1B, 0x00, // Total size
0x00, // AppGlanceSliceType - AppGlanceSliceType_IconAndSubtitle
0x02, // Number of attributes
// Slice Attributes
0x30, // Attribute ID - AttributeIdIcon
0x04, 0x00, // Attribute Length
// Slice icon resource ID:
0x69, 0x00, 0x00, 0x00, //
0x2F, // Attribute ID - AttributeIdSubtitleTemplateString
0x0D, 0x00, // Attribute Length
// Slice subtitle:
'T', 'e', 's', 't', ' ', 's', 'u', 'b', 't', 'i', 't', 'l', 'e',
};
const size_t app_glance_with_slice_missing_expiration_time_size =
sizeof(app_glance_with_slice_missing_expiration_time);
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
(uint8_t *)&app_glance_with_slice_missing_expiration_time,
app_glance_with_slice_missing_expiration_time_size),
S_SUCCESS);
AppGlance read_back_glance = {};
cl_assert_equal_i(app_glance_db_read_glance(&APP_GLANCE_TEST_UUID, &read_back_glance), S_SUCCESS);
cl_assert_equal_i(read_back_glance.slices[0].expiration_time, APP_GLANCE_SLICE_NO_EXPIRATION);
}
// Glance Tests
////////////////////////////////////////////////////////////////
void test_app_glance_db__basic_glance_insert_and_read(void) {
const AppGlance glance = (AppGlance) {
.num_slices = 2,
.slices = {
{
.expiration_time = 1464734484, // (Tue, 31 May 2016 22:41:24 GMT)
.type = AppGlanceSliceType_IconAndSubtitle,
.icon_and_subtitle = {
.icon_resource_id = RESOURCE_ID_SETTINGS_ICON_AIRPLANE,
.template_string = "Test subtitle",
},
},
{
.expiration_time = 1465579430, // (Fri, 10 Jun 2016 17:23:50 GMT)
.type = AppGlanceSliceType_IconAndSubtitle,
.icon_and_subtitle = {
.icon_resource_id = RESOURCE_ID_SETTINGS_ICON_BLUETOOTH,
.template_string = "Test subtitle 2",
},
},
},
};
cl_assert_equal_i(app_glance_db_insert_glance(&APP_GLANCE_TEST_UUID, &glance), S_SUCCESS);
AppGlance read_back_glance = {};
cl_assert_equal_i(app_glance_db_read_glance(&APP_GLANCE_TEST_UUID, &read_back_glance),
S_SUCCESS);
cl_assert_equal_m(&glance, &read_back_glance, sizeof(AppGlance));
}
void test_app_glance_db__reading_nonexistent_glance_returns_does_not_exist(void) {
AppGlance glance = {};
cl_assert_equal_i(app_glance_db_read_glance(&UUID_INVALID, &glance), E_DOES_NOT_EXIST);
}
void test_app_glance_db__reading_glance_with_invalid_arguments_fails(void) {
// NULL UUID fails
AppGlance glance_out = {};
cl_assert_equal_i(app_glance_db_read_glance(NULL, &glance_out), E_INVALID_ARGUMENT);
// NULL glance_out fails
cl_assert_equal_i(app_glance_db_read_glance(&APP_GLANCE_TEST_UUID, NULL), E_INVALID_ARGUMENT);
}
void test_app_glance_db__inserting_glance_with_invalid_arguments_fails(void) {
// NULL UUID fails
const AppGlance glance = {};
cl_assert_equal_i(app_glance_db_insert_glance(NULL, &glance), E_INVALID_ARGUMENT);
// NULL glance fails
cl_assert_equal_i(app_glance_db_insert_glance(&APP_GLANCE_TEST_UUID, NULL), E_INVALID_ARGUMENT);
// Glance with too many slices fails
const AppGlance glance_with_too_many_slices = (AppGlance) {
.num_slices = 1337,
};
cl_assert(glance_with_too_many_slices.num_slices > APP_GLANCE_DB_MAX_SLICES_PER_GLANCE);
cl_assert_equal_i(app_glance_db_insert_glance(&APP_GLANCE_TEST_UUID,
&glance_with_too_many_slices), E_INVALID_ARGUMENT);
// Glance containing a slice with an invalid type fails
const AppGlance glance_containing_slice_with_invalid_type = (AppGlance) {
.num_slices = 1,
.slices = {
{
.expiration_time = 1464734484, // (Tue, 31 May 2016 22:41:24 GMT)
.type = (AppGlanceSliceType)200,
},
},
};
cl_assert(glance_containing_slice_with_invalid_type.slices[0].type >= AppGlanceSliceTypeCount);
cl_assert_equal_i(app_glance_db_insert_glance(&APP_GLANCE_TEST_UUID,
&glance_containing_slice_with_invalid_type),
E_INVALID_ARGUMENT);
}
void test_app_glance_db__read_glance_creation_time(void) {
time_t time_out;
// Reading the creation time of a glance that doesn't exist should return "does not exist"
cl_assert_equal_i(app_glance_db_read_creation_time(&APP_GLANCE_TEST_UUID, &time_out),
E_DOES_NOT_EXIST);
// Insert a glance and check that the creation time we read back matches
test_app_glance_db__basic_glance_blob_insert_and_read();
cl_assert_equal_i(app_glance_db_read_creation_time(&APP_GLANCE_TEST_UUID, &time_out),
S_SUCCESS);
cl_assert_equal_i(time_out, 1464734484);
}
void test_app_glance_db__read_glance_creation_time_with_invalid_arguments_fails(void) {
// NULL UUID fails
time_t time_out;
cl_assert_equal_i(app_glance_db_read_creation_time(NULL, &time_out), E_INVALID_ARGUMENT);
// NULL time_out fails
cl_assert_equal_i(app_glance_db_read_creation_time(&APP_GLANCE_TEST_UUID, NULL),
E_INVALID_ARGUMENT);
}
void test_app_glance_db__empty_glance_insert_after_basic_glance_insert_succeeds(void) {
// Call the basic glance insert test to insert the basic glance
test_app_glance_db__basic_glance_insert_and_read();
// Let some time pass so the creation time of this next glance insertion is newer
rtc_set_time(rtc_get_time() + 10);
// Try inserting an empty glance; this should succeed and clear the glance
AppGlance empty_glance = {};
cl_assert_equal_i(app_glance_db_insert_glance(&APP_GLANCE_TEST_UUID, &empty_glance), S_SUCCESS);
AppGlance read_back_glance = {};
cl_assert_equal_i(app_glance_db_read_glance(&APP_GLANCE_TEST_UUID, &read_back_glance),
S_SUCCESS);
cl_assert_equal_m(&empty_glance, &read_back_glance, sizeof(AppGlance));
}
void test_app_glance_db__insert_no_app_installed(void) {
s_app_install_id = INSTALL_ID_INVALID;
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
s_app_glance_basic, sizeof(s_app_glance_basic)), E_DOES_NOT_EXIST);
}
void test_app_glance_db__insert_app_not_in_cache(void) {
s_app_install_id = 10;
s_app_cache_entry_exists = false;
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
s_app_glance_basic, sizeof(s_app_glance_basic)), S_SUCCESS);
cl_assert_equal_i(fake_event_get_count(), 1);
PebbleEvent e = fake_event_get_last();
cl_assert_equal_i(e.type, PEBBLE_APP_FETCH_REQUEST_EVENT);
cl_assert(!e.app_fetch_request.with_ui);
cl_assert_equal_i(e.app_fetch_request.id, 10);
}
void test_app_glance_db__insert_app_in_cache(void) {
cl_assert_equal_i(app_glance_db_insert((uint8_t *)&APP_GLANCE_TEST_UUID, UUID_SIZE,
s_app_glance_basic, sizeof(s_app_glance_basic)), S_SUCCESS);
cl_assert_equal_i(s_launch_count, 1);
}