1 /* 2 * Copyright 2018, OpenCensus Authors 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 io.opencensus.trace; 18 19 import static com.google.common.truth.Truth.assertThat; 20 21 import java.nio.CharBuffer; 22 import org.junit.Rule; 23 import org.junit.Test; 24 import org.junit.rules.ExpectedException; 25 import org.junit.runner.RunWith; 26 import org.junit.runners.JUnit4; 27 28 /** Unit tests for {@link BigendianEncoding}. */ 29 @RunWith(JUnit4.class) 30 public class BigendianEncodingTest { 31 @Rule public ExpectedException thrown = ExpectedException.none(); 32 33 private static final long FIRST_LONG = 0x1213141516171819L; 34 private static final byte[] FIRST_BYTE_ARRAY = 35 new byte[] {0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19}; 36 private static final char[] FIRST_CHAR_ARRAY = 37 new char[] {'1', '2', '1', '3', '1', '4', '1', '5', '1', '6', '1', '7', '1', '8', '1', '9'}; 38 private static final long SECOND_LONG = 0xFFEEDDCCBBAA9988L; 39 private static final byte[] SECOND_BYTE_ARRAY = 40 new byte[] { 41 (byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC, 42 (byte) 0xBB, (byte) 0xAA, (byte) 0x99, (byte) 0x88 43 }; 44 private static final char[] SECOND_CHAR_ARRAY = 45 new char[] {'f', 'f', 'e', 'e', 'd', 'd', 'c', 'c', 'b', 'b', 'a', 'a', '9', '9', '8', '8'}; 46 private static final byte[] BOTH_BYTE_ARRAY = 47 new byte[] { 48 0x12, 49 0x13, 50 0x14, 51 0x15, 52 0x16, 53 0x17, 54 0x18, 55 0x19, 56 (byte) 0xFF, 57 (byte) 0xEE, 58 (byte) 0xDD, 59 (byte) 0xCC, 60 (byte) 0xBB, 61 (byte) 0xAA, 62 (byte) 0x99, 63 (byte) 0x88 64 }; 65 private static final char[] BOTH_CHAR_ARRAY = 66 new char[] { 67 '1', '2', '1', '3', '1', '4', '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', 'f', 'f', 68 'e', 'e', 'd', 'd', 'c', 'c', 'b', 'b', 'a', 'a', '9', '9', '8', '8' 69 }; 70 71 @Test longToByteArray_Fails()72 public void longToByteArray_Fails() { 73 // These contain bytes not in the decoding. 74 thrown.expect(IllegalArgumentException.class); 75 thrown.expectMessage("array too small"); 76 BigendianEncoding.longToByteArray(123, new byte[BigendianEncoding.LONG_BYTES], 1); 77 } 78 79 @Test longToByteArray()80 public void longToByteArray() { 81 byte[] result1 = new byte[BigendianEncoding.LONG_BYTES]; 82 BigendianEncoding.longToByteArray(FIRST_LONG, result1, 0); 83 assertThat(result1).isEqualTo(FIRST_BYTE_ARRAY); 84 85 byte[] result2 = new byte[BigendianEncoding.LONG_BYTES]; 86 BigendianEncoding.longToByteArray(SECOND_LONG, result2, 0); 87 assertThat(result2).isEqualTo(SECOND_BYTE_ARRAY); 88 89 byte[] result3 = new byte[2 * BigendianEncoding.LONG_BYTES]; 90 BigendianEncoding.longToByteArray(FIRST_LONG, result3, 0); 91 BigendianEncoding.longToByteArray(SECOND_LONG, result3, BigendianEncoding.LONG_BYTES); 92 assertThat(result3).isEqualTo(BOTH_BYTE_ARRAY); 93 } 94 95 @Test longFromByteArray_ArrayToSmall()96 public void longFromByteArray_ArrayToSmall() { 97 // These contain bytes not in the decoding. 98 thrown.expect(IllegalArgumentException.class); 99 thrown.expectMessage("array too small"); 100 BigendianEncoding.longFromByteArray(new byte[BigendianEncoding.LONG_BYTES], 1); 101 } 102 103 @Test longFromByteArray()104 public void longFromByteArray() { 105 assertThat(BigendianEncoding.longFromByteArray(FIRST_BYTE_ARRAY, 0)).isEqualTo(FIRST_LONG); 106 107 assertThat(BigendianEncoding.longFromByteArray(SECOND_BYTE_ARRAY, 0)).isEqualTo(SECOND_LONG); 108 109 assertThat(BigendianEncoding.longFromByteArray(BOTH_BYTE_ARRAY, 0)).isEqualTo(FIRST_LONG); 110 111 assertThat(BigendianEncoding.longFromByteArray(BOTH_BYTE_ARRAY, BigendianEncoding.LONG_BYTES)) 112 .isEqualTo(SECOND_LONG); 113 } 114 115 @Test toFromByteArray()116 public void toFromByteArray() { 117 toFromByteArrayValidate(0x8000000000000000L); 118 toFromByteArrayValidate(-1); 119 toFromByteArrayValidate(0); 120 toFromByteArrayValidate(1); 121 toFromByteArrayValidate(0x7FFFFFFFFFFFFFFFL); 122 } 123 124 @Test longToBase16String()125 public void longToBase16String() { 126 char[] chars1 = new char[BigendianEncoding.LONG_BASE16]; 127 BigendianEncoding.longToBase16String(FIRST_LONG, chars1, 0); 128 assertThat(chars1).isEqualTo(FIRST_CHAR_ARRAY); 129 130 char[] chars2 = new char[BigendianEncoding.LONG_BASE16]; 131 BigendianEncoding.longToBase16String(SECOND_LONG, chars2, 0); 132 assertThat(chars2).isEqualTo(SECOND_CHAR_ARRAY); 133 134 char[] chars3 = new char[2 * BigendianEncoding.LONG_BASE16]; 135 BigendianEncoding.longToBase16String(FIRST_LONG, chars3, 0); 136 BigendianEncoding.longToBase16String(SECOND_LONG, chars3, BigendianEncoding.LONG_BASE16); 137 assertThat(chars3).isEqualTo(BOTH_CHAR_ARRAY); 138 } 139 140 @Test longFromBase16String_InputTooSmall()141 public void longFromBase16String_InputTooSmall() { 142 // Valid base16 strings always have an even length. 143 thrown.expect(IllegalArgumentException.class); 144 thrown.expectMessage("chars too small"); 145 BigendianEncoding.longFromBase16String( 146 CharBuffer.wrap(new char[BigendianEncoding.LONG_BASE16]), 1); 147 } 148 149 @Test longFromBase16String_UnrecongnizedCharacters()150 public void longFromBase16String_UnrecongnizedCharacters() { 151 // These contain bytes not in the decoding. 152 thrown.expect(IllegalArgumentException.class); 153 thrown.expectMessage("invalid character g"); 154 BigendianEncoding.longFromBase16String("0123456789gbcdef", 0); 155 } 156 157 @Test longFromBase16String()158 public void longFromBase16String() { 159 assertThat(BigendianEncoding.longFromBase16String(CharBuffer.wrap(FIRST_CHAR_ARRAY), 0)) 160 .isEqualTo(FIRST_LONG); 161 162 assertThat(BigendianEncoding.longFromBase16String(CharBuffer.wrap(SECOND_CHAR_ARRAY), 0)) 163 .isEqualTo(SECOND_LONG); 164 165 assertThat(BigendianEncoding.longFromBase16String(CharBuffer.wrap(BOTH_CHAR_ARRAY), 0)) 166 .isEqualTo(FIRST_LONG); 167 168 assertThat( 169 BigendianEncoding.longFromBase16String( 170 CharBuffer.wrap(BOTH_CHAR_ARRAY), BigendianEncoding.LONG_BASE16)) 171 .isEqualTo(SECOND_LONG); 172 } 173 174 @Test toFromBase16String()175 public void toFromBase16String() { 176 toFromBase16StringValidate(0x8000000000000000L); 177 toFromBase16StringValidate(-1); 178 toFromBase16StringValidate(0); 179 toFromBase16StringValidate(1); 180 toFromBase16StringValidate(0x7FFFFFFFFFFFFFFFL); 181 } 182 toFromByteArrayValidate(long value)183 private static void toFromByteArrayValidate(long value) { 184 byte[] array = new byte[BigendianEncoding.LONG_BYTES]; 185 BigendianEncoding.longToByteArray(value, array, 0); 186 assertThat(BigendianEncoding.longFromByteArray(array, 0)).isEqualTo(value); 187 } 188 toFromBase16StringValidate(long value)189 private static void toFromBase16StringValidate(long value) { 190 char[] dest = new char[BigendianEncoding.LONG_BASE16]; 191 BigendianEncoding.longToBase16String(value, dest, 0); 192 assertThat(BigendianEncoding.longFromBase16String(CharBuffer.wrap(dest), 0)).isEqualTo(value); 193 } 194 } 195