1 /* 2 * Copyright (C) 2023 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 package android.health.connect; 18 19 import static android.health.connect.Constants.DEFAULT_LONG; 20 import static android.health.connect.PageTokenWrapper.EMPTY_PAGE_TOKEN; 21 22 import static com.google.common.truth.Truth.assertThat; 23 24 import static org.junit.Assert.assertThrows; 25 26 import androidx.test.ext.junit.runners.AndroidJUnit4; 27 28 import org.junit.Test; 29 import org.junit.runner.RunWith; 30 31 import java.time.Instant; 32 33 @RunWith(AndroidJUnit4.class) 34 public class PageTokenWrapperTest { 35 private static final long MAX_ALLOWED_TIME_MILLIS = (1L << 44) - 1; 36 private static final long MAX_ALLOWED_OFFSET = (1 << 18) - 1; 37 38 @Test of_createInstance()39 public void of_createInstance() { 40 boolean isAscending = false; 41 long timeMillis = 123; 42 int offset = 456; 43 PageTokenWrapper wrapper = PageTokenWrapper.of(isAscending, timeMillis, offset); 44 45 assertThat(wrapper.isAscending()).isEqualTo(isAscending); 46 assertThat(wrapper.timeMillis()).isEqualTo(timeMillis); 47 assertThat(wrapper.offset()).isEqualTo(offset); 48 assertThat(wrapper.isTimestampSet()).isTrue(); 49 assertThat(wrapper.isEmpty()).isFalse(); 50 } 51 52 @Test of_offsetTooLarge_setToMax()53 public void of_offsetTooLarge_setToMax() { 54 boolean isAscending = true; 55 PageTokenWrapper wrapper = 56 PageTokenWrapper.of(isAscending, /* timeMillis= */ 0, (int) MAX_ALLOWED_OFFSET + 1); 57 assertThat(wrapper.offset()).isEqualTo(MAX_ALLOWED_OFFSET); 58 } 59 60 @Test of_invalidArgument_throws()61 public void of_invalidArgument_throws() { 62 boolean isAscending = true; 63 Throwable thrown; 64 65 thrown = 66 assertThrows( 67 IllegalArgumentException.class, 68 () -> 69 PageTokenWrapper.of( 70 isAscending, /* timeMillis= */ -1, /* offset= */ 0)); 71 assertThat(thrown.getMessage()).isEqualTo("timestamp can not be negative"); 72 73 thrown = 74 assertThrows( 75 IllegalArgumentException.class, 76 () -> 77 PageTokenWrapper.of( 78 isAscending, /* timeMillis= */ 0, /* offset= */ -1)); 79 assertThat(thrown.getMessage()).isEqualTo("offset can not be negative"); 80 81 thrown = 82 assertThrows( 83 IllegalArgumentException.class, 84 () -> 85 PageTokenWrapper.of( 86 isAscending, MAX_ALLOWED_TIME_MILLIS + 1, /* offset= */ 0)); 87 assertThat(thrown.getMessage()).isEqualTo("timestamp too large"); 88 } 89 90 @Test ofAscending_timestampNotSet()91 public void ofAscending_timestampNotSet() { 92 PageTokenWrapper wrapper = PageTokenWrapper.ofAscending(true); 93 assertThat(wrapper.isAscending()).isTrue(); 94 assertThat(wrapper.isTimestampSet()).isFalse(); 95 assertThat(wrapper.isEmpty()).isFalse(); 96 97 wrapper = PageTokenWrapper.ofAscending(false); 98 assertThat(wrapper.isAscending()).isFalse(); 99 assertThat(wrapper.isTimestampSet()).isFalse(); 100 assertThat(wrapper.isEmpty()).isFalse(); 101 } 102 103 @Test from_validPageToken_expectCorrectResult()104 public void from_validPageToken_expectCorrectResult() { 105 boolean expectedIsAsc = true; 106 boolean unusedDefaultIsAsc = false; 107 long expectedTimeMillis = 1234; 108 int expectedOffset = 5678; 109 110 long validToken = 111 PageTokenWrapper.of(expectedIsAsc, expectedTimeMillis, expectedOffset).encode(); 112 113 PageTokenWrapper wrapper = PageTokenWrapper.from(validToken, unusedDefaultIsAsc); 114 115 assertThat(wrapper.isAscending()).isEqualTo(expectedIsAsc); 116 assertThat(wrapper.timeMillis()).isEqualTo(expectedTimeMillis); 117 assertThat(wrapper.offset()).isEqualTo(expectedOffset); 118 assertThat(wrapper.isEmpty()).isFalse(); 119 } 120 121 @Test from_pageTokenUnset_useDefaultIsAscending()122 public void from_pageTokenUnset_useDefaultIsAscending() { 123 PageTokenWrapper wrapper = 124 PageTokenWrapper.from(DEFAULT_LONG, /* defaultIsAscending= */ true); 125 assertThat(wrapper.isAscending()).isTrue(); 126 assertThat(wrapper.isEmpty()).isFalse(); 127 128 wrapper = PageTokenWrapper.from(DEFAULT_LONG, /* defaultIsAscending= */ false); 129 assertThat(wrapper.isAscending()).isFalse(); 130 assertThat(wrapper.isEmpty()).isFalse(); 131 } 132 133 @Test from_negativePageToken_throws()134 public void from_negativePageToken_throws() { 135 boolean unusedDefault = true; 136 137 Throwable thrown = 138 assertThrows( 139 IllegalArgumentException.class, 140 () -> PageTokenWrapper.from(-100, unusedDefault)); 141 assertThat(thrown).hasMessageThat().contains("pageToken cannot be negative"); 142 } 143 144 @Test encodeAndFromToken_ascending_expectIsAscendingTrue()145 public void encodeAndFromToken_ascending_expectIsAscendingTrue() { 146 boolean unusedDefault = false; 147 PageTokenWrapper expected = 148 PageTokenWrapper.of(/* isAscending= */ true, 1234, /* offset= */ 0); 149 long token = expected.encode(); 150 151 PageTokenWrapper result = PageTokenWrapper.from(token, unusedDefault); 152 assertThat(result.isAscending()).isTrue(); 153 } 154 155 @Test encodeAndFromToken_descending_expectIsAscendingFalse()156 public void encodeAndFromToken_descending_expectIsAscendingFalse() { 157 boolean unusedDefault = true; 158 PageTokenWrapper wrapper = 159 PageTokenWrapper.of(/* isAscending= */ false, 5678, /* offset= */ 0); 160 long token = wrapper.encode(); 161 162 PageTokenWrapper result = PageTokenWrapper.from(token, unusedDefault); 163 assertThat(result.isAscending()).isFalse(); 164 } 165 166 @Test encodeAndFromToken_currentTimestamp_expectCorrectTime()167 public void encodeAndFromToken_currentTimestamp_expectCorrectTime() { 168 boolean unusedDefault = true; 169 long nowTimeMillis = Instant.now().toEpochMilli(); 170 PageTokenWrapper wrapper = 171 PageTokenWrapper.of(/* isAscending= */ false, nowTimeMillis, /* offset= */ 0); 172 long token = wrapper.encode(); 173 174 PageTokenWrapper result = PageTokenWrapper.from(token, unusedDefault); 175 assertThat(result.timeMillis()).isEqualTo(nowTimeMillis); 176 } 177 178 @Test encodeAndFromToken_minTimestamps_expectCorrectTime()179 public void encodeAndFromToken_minTimestamps_expectCorrectTime() { 180 boolean unusedDefault = false; 181 PageTokenWrapper wrapper = 182 PageTokenWrapper.of(/* isAscending= */ true, /* timeMillis= */ 0, /* offset= */ 0); 183 long token = wrapper.encode(); 184 185 PageTokenWrapper result = PageTokenWrapper.from(token, unusedDefault); 186 assertThat(result.timeMillis()).isEqualTo(0); 187 } 188 189 @Test encodeAndFromToken_maxTimestamps_expectCorrectTime()190 public void encodeAndFromToken_maxTimestamps_expectCorrectTime() { 191 boolean unusedDefault = true; 192 PageTokenWrapper wrapper = 193 PageTokenWrapper.of( 194 /* isAscending= */ false, MAX_ALLOWED_TIME_MILLIS, /* offset= */ 0); 195 long token = wrapper.encode(); 196 197 PageTokenWrapper result = PageTokenWrapper.from(token, unusedDefault); 198 assertThat(result.timeMillis()).isEqualTo(MAX_ALLOWED_TIME_MILLIS); 199 } 200 201 @Test encodeAndFromToken_maxOffset_expectCorrectResult()202 public void encodeAndFromToken_maxOffset_expectCorrectResult() { 203 boolean unusedDefault = true; 204 int maxOffset = (1 << 18) - 1; 205 long timestamp = Instant.now().toEpochMilli(); 206 207 PageTokenWrapper wrapper = 208 PageTokenWrapper.of(/* isAscending= */ false, timestamp, maxOffset); 209 long token = wrapper.encode(); 210 211 PageTokenWrapper result = PageTokenWrapper.from(token, unusedDefault); 212 assertThat(result.offset()).isEqualTo(maxOffset); 213 } 214 215 @Test encodeAndFromToken_minOffset_expectCorrectResult()216 public void encodeAndFromToken_minOffset_expectCorrectResult() { 217 boolean unusedDefault = false; 218 int minOffset = 0; 219 long timestamp = Instant.now().toEpochMilli(); 220 PageTokenWrapper wrapper = 221 PageTokenWrapper.of(/* isAscending= */ true, timestamp, minOffset); 222 long token = wrapper.encode(); 223 224 PageTokenWrapper result = PageTokenWrapper.from(token, unusedDefault); 225 assertThat(result.offset()).isEqualTo(minOffset); 226 } 227 228 @Test encode_pageTokenUnset_returnsDefaultLong()229 public void encode_pageTokenUnset_returnsDefaultLong() { 230 assertThat(EMPTY_PAGE_TOKEN.encode()).isEqualTo(DEFAULT_LONG); 231 assertThat(PageTokenWrapper.ofAscending(true).encode()).isEqualTo(DEFAULT_LONG); 232 assertThat(PageTokenWrapper.ofAscending(false).encode()).isEqualTo(DEFAULT_LONG); 233 } 234 235 @Test emptyPageToken_isEmpty_expectTrue()236 public void emptyPageToken_isEmpty_expectTrue() { 237 assertThat(EMPTY_PAGE_TOKEN.isEmpty()).isTrue(); 238 } 239 240 @Test equals_sameValue_expectTrue()241 public void equals_sameValue_expectTrue() { 242 PageTokenWrapper wrapper1 = 243 PageTokenWrapper.of( 244 /* isAscending= */ false, /* timeMillis= */ 1234, /* offset= */ 567); 245 PageTokenWrapper wrapper2 = 246 PageTokenWrapper.of( 247 /* isAscending= */ false, /* timeMillis= */ 1234, /* offset= */ 567); 248 249 assertThat(wrapper1.equals(wrapper2)).isTrue(); 250 } 251 252 @Test equals_differentValue_expectFalse()253 public void equals_differentValue_expectFalse() { 254 PageTokenWrapper wrapper = 255 PageTokenWrapper.of( 256 /* isAscending= */ false, /* timeMillis= */ 1234, /* offset= */ 567); 257 PageTokenWrapper differentIsAscending = 258 PageTokenWrapper.of( 259 /* isAscending= */ true, /* timeMillis= */ 1234, /* offset= */ 567); 260 PageTokenWrapper differentTime = 261 PageTokenWrapper.of( 262 /* isAscending= */ false, /* timeMillis= */ 123, /* offset= */ 567); 263 PageTokenWrapper differentOffset = 264 PageTokenWrapper.of( 265 /* isAscending= */ false, /* timeMillis= */ 1234, /* offset= */ 5678); 266 267 assertThat(wrapper.equals(differentIsAscending)).isFalse(); 268 assertThat(wrapper.equals(differentTime)).isFalse(); 269 assertThat(wrapper.equals(differentOffset)).isFalse(); 270 } 271 272 @Test equals_nonEmptyAndEmpty_expectFalse()273 public void equals_nonEmptyAndEmpty_expectFalse() { 274 PageTokenWrapper ascWrapper = PageTokenWrapper.ofAscending(true); 275 PageTokenWrapper descWrapper = PageTokenWrapper.ofAscending(false); 276 277 assertThat(EMPTY_PAGE_TOKEN.equals(ascWrapper)).isFalse(); 278 assertThat(EMPTY_PAGE_TOKEN.equals(descWrapper)).isFalse(); 279 } 280 } 281