+
+TEST(camera_metadata, delete_metadata) {
+ camera_metadata_t *m = NULL;
+ const size_t entry_capacity = 50;
+ const size_t data_capacity = 450;
+
+ int result;
+
+ m = allocate_camera_metadata(entry_capacity, data_capacity);
+
+ size_t num_entries = 5;
+ size_t data_per_entry =
+ calculate_camera_metadata_entry_data_size(TYPE_INT64, 1);
+ size_t num_data = num_entries * data_per_entry;
+
+ // Delete an entry with data
+
+ add_test_metadata(m, num_entries);
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+
+ result = delete_camera_metadata_entry(m, 1);
+ EXPECT_EQ(OK, result);
+ num_entries--;
+ num_data -= data_per_entry;
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+ EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
+
+ result = delete_camera_metadata_entry(m, 4);
+ EXPECT_EQ(ERROR, result);
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+ EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
+
+ for (size_t i = 0; i < num_entries; i++) {
+ camera_metadata_entry e;
+ result = get_camera_metadata_entry(m, i, &e);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i;
+ EXPECT_EQ(exposureTime, *e.data.i64);
+ }
+
+ // Delete an entry with no data, at end of array
+
+ int32_t frameCount = 12;
+ result = add_camera_metadata_entry(m,
+ ANDROID_REQUEST_FRAME_COUNT,
+ &frameCount, 1);
+ EXPECT_EQ(OK, result);
+ num_entries++;
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+ EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
+
+ camera_metadata_entry e;
+ result = get_camera_metadata_entry(m, 4, &e);
+ EXPECT_EQ(OK, result);
+
+ EXPECT_EQ((size_t)4, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(frameCount, *e.data.i32);
+
+ result = delete_camera_metadata_entry(m, 4);
+ EXPECT_EQ(OK, result);
+
+ num_entries--;
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+ EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
+
+ result = delete_camera_metadata_entry(m, 4);
+ EXPECT_EQ(ERROR, result);
+
+ result = get_camera_metadata_entry(m, 4, &e);
+ EXPECT_EQ(ERROR, result);
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+ EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
+
+ // Delete with extra data on end of array
+ result = delete_camera_metadata_entry(m, 3);
+ EXPECT_EQ(OK, result);
+ num_entries--;
+ num_data -= data_per_entry;
+
+ for (size_t i = 0; i < num_entries; i++) {
+ camera_metadata_entry e2;
+ result = get_camera_metadata_entry(m, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+
+ // Delete without extra data in front of array
+
+ frameCount = 1001;
+ result = add_camera_metadata_entry(m,
+ ANDROID_REQUEST_FRAME_COUNT,
+ &frameCount, 1);
+ EXPECT_EQ(OK, result);
+ num_entries++;
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+ EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
+
+ result = sort_camera_metadata(m);
+ EXPECT_EQ(OK, result);
+
+ result = find_camera_metadata_entry(m,
+ ANDROID_REQUEST_FRAME_COUNT, &e);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(frameCount, *e.data.i32);
+
+ result = delete_camera_metadata_entry(m, e.index);
+ EXPECT_EQ(OK, result);
+ num_entries--;
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+ EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
+
+ for (size_t i = 0; i < num_entries; i++) {
+ camera_metadata_entry e2;
+ result = get_camera_metadata_entry(m, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+}
+
+TEST(camera_metadata, update_metadata) {
+ camera_metadata_t *m = NULL;
+ const size_t entry_capacity = 50;
+ const size_t data_capacity = 450;
+
+ int result;
+
+ m = allocate_camera_metadata(entry_capacity, data_capacity);
+
+ size_t num_entries = 5;
+ size_t data_per_entry =
+ calculate_camera_metadata_entry_data_size(TYPE_INT64, 1);
+ size_t num_data = num_entries * data_per_entry;
+
+ add_test_metadata(m, num_entries);
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+
+ // Update with same-size data, doesn't fit in entry
+
+ int64_t newExposureTime = 1000;
+ camera_metadata_entry_t e;
+ result = update_camera_metadata_entry(m,
+ 0, &newExposureTime, 1, &e);
+ EXPECT_EQ(OK, result);
+
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newExposureTime, *e.data.i64);
+
+ e.count = 0;
+ result = get_camera_metadata_entry(m,
+ 0, &e);
+
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newExposureTime, *e.data.i64);
+
+ for (size_t i = 1; i < num_entries; i++) {
+ camera_metadata_entry e2;
+ result = get_camera_metadata_entry(m, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = 100 + 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+
+ // Update with larger data
+ int64_t newExposures[2] = { 5000, 6000 };
+ result = update_camera_metadata_entry(m,
+ 0, newExposures, 2, &e);
+ EXPECT_EQ(OK, result);
+ num_data += data_per_entry;
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ EXPECT_EQ((size_t)2, e.count);
+ EXPECT_EQ(newExposures[0], e.data.i64[0]);
+ EXPECT_EQ(newExposures[1], e.data.i64[1]);
+
+ e.count = 0;
+ result = get_camera_metadata_entry(m,
+ 0, &e);
+
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ EXPECT_EQ((size_t)2, e.count);
+ EXPECT_EQ(newExposures[0], e.data.i64[0]);
+ EXPECT_EQ(newExposures[1], e.data.i64[1]);
+
+ for (size_t i = 1; i < num_entries; i++) {
+ camera_metadata_entry e2;
+ result = get_camera_metadata_entry(m, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = 100 + 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+
+ // Update with smaller data
+ newExposureTime = 100;
+ result = update_camera_metadata_entry(m,
+ 0, &newExposureTime, 1, &e);
+ EXPECT_EQ(OK, result);
+
+ num_data -= data_per_entry;
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newExposureTime, *e.data.i64);
+
+ e.count = 0;
+ result = get_camera_metadata_entry(m,
+ 0, &e);
+
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newExposureTime, *e.data.i64);
+
+ for (size_t i = 1; i < num_entries; i++) {
+ camera_metadata_entry e2;
+ result = get_camera_metadata_entry(m, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = 100 + 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+
+ // Update with size fitting in entry
+
+ int32_t frameCount = 1001;
+ result = add_camera_metadata_entry(m,
+ ANDROID_REQUEST_FRAME_COUNT,
+ &frameCount, 1);
+ EXPECT_EQ(OK, result);
+ num_entries++;
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+ EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
+
+ result = sort_camera_metadata(m);
+ EXPECT_EQ(OK, result);
+
+ result = find_camera_metadata_entry(m,
+ ANDROID_REQUEST_FRAME_COUNT, &e);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(frameCount, *e.data.i32);
+
+ int32_t newFrameCount = 0x12349876;
+ result = update_camera_metadata_entry(m,
+ 0, &newFrameCount, 1, &e);
+
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newFrameCount, *e.data.i32);
+
+ result = find_camera_metadata_entry(m,
+ ANDROID_REQUEST_FRAME_COUNT, &e);
+
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newFrameCount, *e.data.i32);
+
+ for (size_t i = 1; i < num_entries; i++) {
+ camera_metadata_entry e2;
+ result = get_camera_metadata_entry(m, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+
+ // Update to bigger than entry
+
+ int32_t newFrameCounts[4] = { 0x0, 0x1, 0x10, 0x100 };
+
+ result = update_camera_metadata_entry(m,
+ 0, &newFrameCounts, 4, &e);
+
+ EXPECT_EQ(OK, result);
+
+ num_data += calculate_camera_metadata_entry_data_size(TYPE_INT32,
+ 4);
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)4, e.count);
+ EXPECT_EQ(newFrameCounts[0], e.data.i32[0]);
+ EXPECT_EQ(newFrameCounts[1], e.data.i32[1]);
+ EXPECT_EQ(newFrameCounts[2], e.data.i32[2]);
+ EXPECT_EQ(newFrameCounts[3], e.data.i32[3]);
+
+ e.count = 0;
+
+ result = find_camera_metadata_entry(m,
+ ANDROID_REQUEST_FRAME_COUNT, &e);
+
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)4, e.count);
+ EXPECT_EQ(newFrameCounts[0], e.data.i32[0]);
+ EXPECT_EQ(newFrameCounts[1], e.data.i32[1]);
+ EXPECT_EQ(newFrameCounts[2], e.data.i32[2]);
+ EXPECT_EQ(newFrameCounts[3], e.data.i32[3]);
+
+ for (size_t i = 1; i < num_entries; i++) {
+ camera_metadata_entry e2;
+ result = get_camera_metadata_entry(m, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+
+ // Update to smaller than entry
+ result = update_camera_metadata_entry(m,
+ 0, &newFrameCount, 1, &e);
+
+ EXPECT_EQ(OK, result);
+
+ num_data -= camera_metadata_type_size[TYPE_INT32] * 4;
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newFrameCount, *e.data.i32);
+
+ result = find_camera_metadata_entry(m,
+ ANDROID_REQUEST_FRAME_COUNT, &e);
+
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newFrameCount, *e.data.i32);
+
+ for (size_t i = 1; i < num_entries; i++) {
+ camera_metadata_entry_t e2;
+ result = get_camera_metadata_entry(m, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+
+ // Setup new buffer with no spare data space
+
+ result = update_camera_metadata_entry(m,
+ 1, newExposures, 2, &e);
+ EXPECT_EQ(OK, result);
+
+ num_data += data_per_entry;
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
+
+ EXPECT_EQ((size_t)1, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ EXPECT_EQ((size_t)2, e.count);
+ EXPECT_EQ(newExposures[0], e.data.i64[0]);
+ EXPECT_EQ(newExposures[1], e.data.i64[1]);
+
+ camera_metadata_t *m2;
+ m2 = allocate_camera_metadata(get_camera_metadata_entry_count(m),
+ get_camera_metadata_data_count(m));
+ EXPECT_NOT_NULL(m2);
+
+ result = append_camera_metadata(m2, m);
+ EXPECT_EQ(OK, result);
+
+ result = find_camera_metadata_entry(m2,
+ ANDROID_REQUEST_FRAME_COUNT, &e);
+
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newFrameCount, *e.data.i32);
+
+ // Update when there's no more room
+
+ result = update_camera_metadata_entry(m2,
+ 0, &newFrameCounts, 4, &e);
+ EXPECT_EQ(ERROR, result);
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m2));
+
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newFrameCount, *e.data.i32);
+
+ // Update when there's no data room, but change fits into entry
+
+ newFrameCount = 5;
+ result = update_camera_metadata_entry(m2,
+ 0, &newFrameCount, 1, &e);
+ EXPECT_EQ(OK, result);
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m2));
+
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newFrameCount, *e.data.i32);
+
+ result = find_camera_metadata_entry(m2,
+ ANDROID_REQUEST_FRAME_COUNT, &e);
+
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newFrameCount, *e.data.i32);
+
+ result = get_camera_metadata_entry(m2, 1, &e);
+ EXPECT_EQ((size_t)1, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ EXPECT_EQ((size_t)2, e.count);
+ EXPECT_EQ(newExposures[0], e.data.i64[0]);
+ EXPECT_EQ(newExposures[1], e.data.i64[1]);
+
+ for (size_t i = 2; i < num_entries; i++) {
+ camera_metadata_entry_t e2;
+ result = get_camera_metadata_entry(m2, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+
+ // Update when there's no data room, but data size doesn't change
+
+ newExposures[0] = 1000;
+
+ result = update_camera_metadata_entry(m2,
+ 1, newExposures, 2, &e);
+ EXPECT_EQ(OK, result);
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m2));
+
+ EXPECT_EQ((size_t)1, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ EXPECT_EQ((size_t)2, e.count);
+ EXPECT_EQ(newExposures[0], e.data.i64[0]);
+ EXPECT_EQ(newExposures[1], e.data.i64[1]);
+
+ result = find_camera_metadata_entry(m2,
+ ANDROID_REQUEST_FRAME_COUNT, &e);
+
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newFrameCount, *e.data.i32);
+
+ for (size_t i = 2; i < num_entries; i++) {
+ camera_metadata_entry_t e2;
+ result = get_camera_metadata_entry(m2, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+
+ // Update when there's no data room, but data size shrinks
+
+ result = update_camera_metadata_entry(m2,
+ 1, &newExposureTime, 1, &e);
+ EXPECT_EQ(OK, result);
+
+ num_data -= calculate_camera_metadata_entry_data_size(TYPE_INT64, 2);
+ num_data += calculate_camera_metadata_entry_data_size(TYPE_INT64, 1);
+
+ EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2));
+ EXPECT_EQ(num_data, get_camera_metadata_data_count(m2));
+
+ EXPECT_EQ((size_t)1, e.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
+ EXPECT_EQ(TYPE_INT64, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newExposureTime, e.data.i64[0]);
+
+ result = find_camera_metadata_entry(m2,
+ ANDROID_REQUEST_FRAME_COUNT, &e);
+
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ((size_t)0, e.index);
+ EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
+ EXPECT_EQ(TYPE_INT32, e.type);
+ EXPECT_EQ((size_t)1, e.count);
+ EXPECT_EQ(newFrameCount, *e.data.i32);
+
+ for (size_t i = 2; i < num_entries; i++) {
+ camera_metadata_entry_t e2;
+ result = get_camera_metadata_entry(m2, i, &e2);
+ EXPECT_EQ(OK, result);
+ EXPECT_EQ(i, e2.index);
+ EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
+ EXPECT_EQ(TYPE_INT64, e2.type);
+ int64_t exposureTime = 100 * i;
+ EXPECT_EQ(exposureTime, *e2.data.i64);
+ }
+
+}