Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 1 | // Copyright (C) 2017 The Android Open Source Project |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
Yi Jin | 4e84310 | 2018-02-14 15:36:18 -0800 | [diff] [blame] | 14 | #define DEBUG false |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 15 | #include "Log.h" |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 16 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 17 | #include "FdBuffer.h" |
| 18 | #include "PrivacyBuffer.h" |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 19 | |
| 20 | #include <android-base/file.h> |
| 21 | #include <android-base/test_utils.h> |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 22 | #include <android/os/IncidentReportArgs.h> |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 23 | #include <gmock/gmock.h> |
| 24 | #include <gtest/gtest.h> |
| 25 | #include <string.h> |
| 26 | |
| 27 | using namespace android; |
| 28 | using namespace android::base; |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 29 | using namespace android::os; |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 30 | using namespace android::os::incidentd; |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 31 | using ::testing::StrEq; |
| 32 | using ::testing::Test; |
| 33 | using ::testing::internal::CaptureStdout; |
| 34 | using ::testing::internal::GetCapturedStdout; |
| 35 | |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 36 | const uint8_t OTHER_TYPE = 1; |
| 37 | const uint8_t STRING_TYPE = 9; |
| 38 | const uint8_t MESSAGE_TYPE = 11; |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 39 | const std::string STRING_FIELD_0 = "\x02\viamtestdata"; |
| 40 | const std::string VARINT_FIELD_1 = "\x08\x96\x01"; // 150 |
| 41 | const std::string STRING_FIELD_2 = "\x12\vandroidwins"; |
| 42 | const std::string FIX64_FIELD_3 = "\x19\xff\xff\xff\xff\xff\xff\xff\xff"; // -1 |
| 43 | const std::string FIX32_FIELD_4 = "\x25\xff\xff\xff\xff"; // -1 |
| 44 | const std::string MESSAGE_FIELD_5 = "\x2a\x10" + VARINT_FIELD_1 + STRING_FIELD_2; |
Yi Jin | ba7ee6f | 2018-04-11 16:11:05 -0700 | [diff] [blame] | 45 | const std::string NEGATIVE_VARINT_FIELD_6 = "\x30\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01"; // -1 |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 46 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 47 | class PrivacyBufferTest : public Test { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 48 | public: |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 49 | virtual ~PrivacyBufferTest() { |
George Burgess IV | bbe04e8 | 2017-09-19 16:36:02 -0700 | [diff] [blame] | 50 | // Delete in reverse order of construction, to be consistent with |
| 51 | // regular allocation/deallocation. |
| 52 | while (!privacies.empty()) { |
| 53 | delete privacies.back(); |
| 54 | privacies.pop_back(); |
| 55 | } |
| 56 | } |
| 57 | |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 58 | virtual void SetUp() override { ASSERT_NE(tf.fd, -1); } |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 59 | |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 60 | void writeToFdBuffer(std::string str) { |
Wei Wang | 254102d | 2017-11-09 21:45:29 -0800 | [diff] [blame] | 61 | ASSERT_TRUE(WriteStringToFile(str, tf.path)); |
Yi Jin | e3dab2d | 2018-03-22 16:56:39 -0700 | [diff] [blame] | 62 | ASSERT_EQ(NO_ERROR, buffer.read(tf.fd, 10000)); |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 63 | ASSERT_EQ(str.size(), buffer.size()); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 64 | } |
| 65 | |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 66 | void assertBuffer(PrivacyBuffer& buf, std::string expected) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 67 | ASSERT_EQ(buf.size(), expected.size()); |
| 68 | CaptureStdout(); |
| 69 | ASSERT_EQ(buf.flush(STDOUT_FILENO), NO_ERROR); |
| 70 | ASSERT_THAT(GetCapturedStdout(), StrEq(expected)); |
| 71 | } |
| 72 | |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 73 | void assertStrip(uint8_t dest, std::string expected, Privacy* policy) { |
Yi Jin | 3ec5cc7 | 2018-01-26 13:42:43 -0800 | [diff] [blame] | 74 | PrivacySpec spec = PrivacySpec::new_spec(dest); |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 75 | EncodedBuffer::iterator bufData = buffer.data(); |
| 76 | PrivacyBuffer privacyBuf(policy, bufData); |
| 77 | ASSERT_EQ(privacyBuf.strip(spec), NO_ERROR); |
| 78 | assertBuffer(privacyBuf, expected); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 79 | } |
| 80 | |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 81 | void assertStripByFields(uint8_t dest, std::string expected, int size, Privacy* privacy, ...) { |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 82 | Privacy* list[size + 1]; |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 83 | list[0] = privacy; |
| 84 | va_list args; |
| 85 | va_start(args, privacy); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 86 | for (int i = 1; i < size; i++) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 87 | Privacy* p = va_arg(args, Privacy*); |
| 88 | list[i] = p; |
| 89 | } |
| 90 | va_end(args); |
| 91 | list[size] = NULL; |
Yi Jin | 7e0b4e5 | 2017-09-12 20:00:25 -0700 | [diff] [blame] | 92 | assertStrip(dest, expected, create_message_privacy(300, list)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 93 | } |
| 94 | |
George Burgess IV | bbe04e8 | 2017-09-19 16:36:02 -0700 | [diff] [blame] | 95 | Privacy* create_privacy(uint32_t field_id, uint8_t type, uint8_t dest) { |
| 96 | Privacy* p = new_uninit_privacy(); |
| 97 | p->field_id = field_id; |
| 98 | p->type = type; |
| 99 | p->children = NULL; |
| 100 | p->dest = dest; |
| 101 | p->patterns = NULL; |
| 102 | return p; |
| 103 | } |
| 104 | |
| 105 | Privacy* create_message_privacy(uint32_t field_id, Privacy** children) { |
| 106 | Privacy* p = new_uninit_privacy(); |
| 107 | p->field_id = field_id; |
| 108 | p->type = MESSAGE_TYPE; |
| 109 | p->children = children; |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 110 | p->dest = DEST_DEFAULT_VALUE; |
George Burgess IV | bbe04e8 | 2017-09-19 16:36:02 -0700 | [diff] [blame] | 111 | p->patterns = NULL; |
| 112 | return p; |
| 113 | } |
| 114 | |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 115 | FdBuffer buffer; |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 116 | |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 117 | private: |
| 118 | TemporaryFile tf; |
George Burgess IV | bbe04e8 | 2017-09-19 16:36:02 -0700 | [diff] [blame] | 119 | // Littering this code with unique_ptr (or similar) is ugly, so we just |
| 120 | // mass-free everything after the test completes. |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 121 | std::vector<Privacy*> privacies; |
George Burgess IV | bbe04e8 | 2017-09-19 16:36:02 -0700 | [diff] [blame] | 122 | |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 123 | Privacy* new_uninit_privacy() { |
George Burgess IV | bbe04e8 | 2017-09-19 16:36:02 -0700 | [diff] [blame] | 124 | Privacy* p = new Privacy; |
| 125 | privacies.push_back(p); |
| 126 | return p; |
| 127 | } |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 128 | }; |
| 129 | |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 130 | TEST_F(PrivacyBufferTest, NullPolicy) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 131 | writeToFdBuffer(STRING_FIELD_0); |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 132 | assertStrip(DEST_EXPLICIT, STRING_FIELD_0, NULL); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 133 | } |
| 134 | |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 135 | TEST_F(PrivacyBufferTest, StripUnsetField) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 136 | writeToFdBuffer(STRING_FIELD_0); |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 137 | assertStripByFields(DEST_AUTOMATIC, "", 1, create_privacy(0, STRING_TYPE, DEST_UNSET)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 138 | } |
| 139 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 140 | TEST_F(PrivacyBufferTest, StripVarintField) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 141 | writeToFdBuffer(VARINT_FIELD_1); |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 142 | assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(1, OTHER_TYPE, DEST_LOCAL)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 143 | } |
| 144 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 145 | TEST_F(PrivacyBufferTest, StripLengthDelimitedField_String) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 146 | writeToFdBuffer(STRING_FIELD_2); |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 147 | assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(2, STRING_TYPE, DEST_LOCAL)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 148 | } |
| 149 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 150 | TEST_F(PrivacyBufferTest, StripFixed64Field) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 151 | writeToFdBuffer(FIX64_FIELD_3); |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 152 | assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(3, OTHER_TYPE, DEST_LOCAL)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 153 | } |
| 154 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 155 | TEST_F(PrivacyBufferTest, StripFixed32Field) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 156 | writeToFdBuffer(FIX32_FIELD_4); |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 157 | assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(4, OTHER_TYPE, DEST_LOCAL)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 158 | } |
| 159 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 160 | TEST_F(PrivacyBufferTest, StripLengthDelimitedField_Message) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 161 | writeToFdBuffer(MESSAGE_FIELD_5); |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 162 | assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(5, MESSAGE_TYPE, DEST_LOCAL)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 163 | } |
| 164 | |
Yi Jin | ba7ee6f | 2018-04-11 16:11:05 -0700 | [diff] [blame] | 165 | TEST_F(PrivacyBufferTest, StripNegativeVarint) { |
| 166 | writeToFdBuffer(NEGATIVE_VARINT_FIELD_6); |
| 167 | assertStripByFields(DEST_EXPLICIT, "", 1, create_privacy(6, OTHER_TYPE, DEST_LOCAL)); |
| 168 | } |
| 169 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 170 | TEST_F(PrivacyBufferTest, NoStripVarintField) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 171 | writeToFdBuffer(VARINT_FIELD_1); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 172 | assertStripByFields(DEST_EXPLICIT, VARINT_FIELD_1, 1, |
| 173 | create_privacy(1, OTHER_TYPE, DEST_AUTOMATIC)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 174 | } |
| 175 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 176 | TEST_F(PrivacyBufferTest, NoStripLengthDelimitedField_String) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 177 | writeToFdBuffer(STRING_FIELD_2); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 178 | assertStripByFields(DEST_EXPLICIT, STRING_FIELD_2, 1, |
| 179 | create_privacy(2, STRING_TYPE, DEST_AUTOMATIC)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 180 | } |
| 181 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 182 | TEST_F(PrivacyBufferTest, NoStripFixed64Field) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 183 | writeToFdBuffer(FIX64_FIELD_3); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 184 | assertStripByFields(DEST_EXPLICIT, FIX64_FIELD_3, 1, |
| 185 | create_privacy(3, OTHER_TYPE, DEST_AUTOMATIC)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 186 | } |
| 187 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 188 | TEST_F(PrivacyBufferTest, NoStripFixed32Field) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 189 | writeToFdBuffer(FIX32_FIELD_4); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 190 | assertStripByFields(DEST_EXPLICIT, FIX32_FIELD_4, 1, |
| 191 | create_privacy(4, OTHER_TYPE, DEST_AUTOMATIC)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 192 | } |
| 193 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 194 | TEST_F(PrivacyBufferTest, NoStripLengthDelimitedField_Message) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 195 | writeToFdBuffer(MESSAGE_FIELD_5); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 196 | assertStripByFields(DEST_EXPLICIT, MESSAGE_FIELD_5, 1, |
| 197 | create_privacy(5, MESSAGE_TYPE, DEST_AUTOMATIC)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 198 | } |
| 199 | |
Yi Jin | ba7ee6f | 2018-04-11 16:11:05 -0700 | [diff] [blame] | 200 | TEST_F(PrivacyBufferTest, NoStripNegativeVarintField) { |
| 201 | writeToFdBuffer(NEGATIVE_VARINT_FIELD_6); |
| 202 | assertStripByFields(DEST_EXPLICIT, NEGATIVE_VARINT_FIELD_6, 1, |
| 203 | create_privacy(6, OTHER_TYPE, DEST_AUTOMATIC)); |
| 204 | } |
| 205 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 206 | TEST_F(PrivacyBufferTest, StripVarintAndString) { |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 207 | writeToFdBuffer(STRING_FIELD_0 + VARINT_FIELD_1 + STRING_FIELD_2 + FIX64_FIELD_3 + |
| 208 | FIX32_FIELD_4); |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 209 | std::string expected = STRING_FIELD_0 + FIX64_FIELD_3 + FIX32_FIELD_4; |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 210 | assertStripByFields(DEST_EXPLICIT, expected, 2, create_privacy(1, OTHER_TYPE, DEST_LOCAL), |
| 211 | create_privacy(2, STRING_TYPE, DEST_LOCAL)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 212 | } |
| 213 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 214 | TEST_F(PrivacyBufferTest, StripVarintAndFixed64) { |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 215 | writeToFdBuffer(STRING_FIELD_0 + VARINT_FIELD_1 + STRING_FIELD_2 + FIX64_FIELD_3 + |
| 216 | FIX32_FIELD_4); |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 217 | std::string expected = STRING_FIELD_0 + STRING_FIELD_2 + FIX32_FIELD_4; |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 218 | assertStripByFields(DEST_EXPLICIT, expected, 2, create_privacy(1, OTHER_TYPE, DEST_LOCAL), |
| 219 | create_privacy(3, OTHER_TYPE, DEST_LOCAL)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 220 | } |
| 221 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 222 | TEST_F(PrivacyBufferTest, StripVarintInNestedMessage) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 223 | writeToFdBuffer(STRING_FIELD_0 + MESSAGE_FIELD_5); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 224 | Privacy* list[] = {create_privacy(1, OTHER_TYPE, DEST_LOCAL), NULL}; |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 225 | std::string expected = STRING_FIELD_0 + "\x2a\xd" + STRING_FIELD_2; |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 226 | assertStripByFields(DEST_EXPLICIT, expected, 1, create_message_privacy(5, list)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 227 | } |
| 228 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 229 | TEST_F(PrivacyBufferTest, StripFix64AndVarintInNestedMessage) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 230 | writeToFdBuffer(STRING_FIELD_0 + FIX64_FIELD_3 + MESSAGE_FIELD_5); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 231 | Privacy* list[] = {create_privacy(1, OTHER_TYPE, DEST_LOCAL), NULL}; |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 232 | std::string expected = STRING_FIELD_0 + "\x2a\xd" + STRING_FIELD_2; |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 233 | assertStripByFields(DEST_EXPLICIT, expected, 2, create_privacy(3, OTHER_TYPE, DEST_LOCAL), |
| 234 | create_message_privacy(5, list)); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 235 | } |
| 236 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 237 | TEST_F(PrivacyBufferTest, ClearAndStrip) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 238 | string data = STRING_FIELD_0 + VARINT_FIELD_1; |
| 239 | writeToFdBuffer(data); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 240 | Privacy* list[] = {create_privacy(1, OTHER_TYPE, DEST_LOCAL), NULL}; |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 241 | EncodedBuffer::iterator bufData = buffer.data(); |
| 242 | PrivacyBuffer privacyBuf(create_message_privacy(300, list), bufData); |
Yi Jin | 3ec5cc7 | 2018-01-26 13:42:43 -0800 | [diff] [blame] | 243 | PrivacySpec spec1 = PrivacySpec::new_spec(DEST_EXPLICIT); |
| 244 | PrivacySpec spec2 = PrivacySpec::new_spec(DEST_LOCAL); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 245 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 246 | ASSERT_EQ(privacyBuf.strip(spec1), NO_ERROR); |
| 247 | assertBuffer(privacyBuf, STRING_FIELD_0); |
| 248 | ASSERT_EQ(privacyBuf.strip(spec2), NO_ERROR); |
| 249 | assertBuffer(privacyBuf, data); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 250 | } |
| 251 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 252 | TEST_F(PrivacyBufferTest, BadDataInFdBuffer) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 253 | writeToFdBuffer("iambaddata"); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 254 | Privacy* list[] = {create_privacy(4, OTHER_TYPE, DEST_AUTOMATIC), NULL}; |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 255 | EncodedBuffer::iterator bufData = buffer.data(); |
| 256 | PrivacyBuffer privacyBuf(create_message_privacy(300, list), bufData); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 257 | PrivacySpec spec; |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 258 | ASSERT_EQ(privacyBuf.strip(spec), BAD_VALUE); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 259 | } |
| 260 | |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 261 | TEST_F(PrivacyBufferTest, BadDataInNestedMessage) { |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 262 | writeToFdBuffer(STRING_FIELD_0 + MESSAGE_FIELD_5 + "aoeoe"); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 263 | Privacy* list[] = {create_privacy(1, OTHER_TYPE, DEST_LOCAL), NULL}; |
| 264 | Privacy* field5[] = {create_message_privacy(5, list), NULL}; |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 265 | EncodedBuffer::iterator bufData = buffer.data(); |
| 266 | PrivacyBuffer privacyBuf(create_message_privacy(300, field5), bufData); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 267 | PrivacySpec spec; |
Yi Jin | c23fad2 | 2017-09-15 17:24:59 -0700 | [diff] [blame] | 268 | ASSERT_EQ(privacyBuf.strip(spec), BAD_VALUE); |
Yi Jin | 99c248f | 2017-08-25 18:11:58 -0700 | [diff] [blame] | 269 | } |
Yi Jin | be6de30 | 2017-10-24 12:30:24 -0700 | [diff] [blame] | 270 | |
| 271 | TEST_F(PrivacyBufferTest, SelfRecursionMessage) { |
| 272 | string input = "\x2a\"" + VARINT_FIELD_1 + STRING_FIELD_2 + MESSAGE_FIELD_5; |
| 273 | writeToFdBuffer(input); |
| 274 | Privacy* field5 = create_message_privacy(5, NULL); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 275 | Privacy* list[] = {create_privacy(1, OTHER_TYPE, DEST_LOCAL), field5, NULL}; |
Yi Jin | be6de30 | 2017-10-24 12:30:24 -0700 | [diff] [blame] | 276 | field5->children = list; |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 277 | std::string expected = "\x2a\x1c" + STRING_FIELD_2 + "\x2a\xd" + STRING_FIELD_2; |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 278 | assertStrip(DEST_EXPLICIT, expected, field5); |
Yi Jin | be6de30 | 2017-10-24 12:30:24 -0700 | [diff] [blame] | 279 | } |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 280 | |
| 281 | TEST_F(PrivacyBufferTest, AutoMessage) { |
| 282 | writeToFdBuffer(STRING_FIELD_2 + MESSAGE_FIELD_5); |
Yi Jin | b592e3b | 2018-02-01 15:17:04 -0800 | [diff] [blame] | 283 | Privacy* list[] = {create_privacy(1, OTHER_TYPE, DEST_LOCAL), NULL}; |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 284 | Privacy* autoMsg = create_privacy(5, MESSAGE_TYPE, DEST_AUTOMATIC); |
| 285 | autoMsg->children = list; |
Yi Jin | 6cacbcb | 2018-03-30 14:04:52 -0700 | [diff] [blame] | 286 | std::string expected = "\x2a\xd" + STRING_FIELD_2; |
Yi Jin | bdf5894 | 2017-11-14 17:58:19 -0800 | [diff] [blame] | 287 | assertStripByFields(DEST_AUTOMATIC, expected, 1, autoMsg); |
Yi Jin | c858e27 | 2018-03-28 15:32:50 -0700 | [diff] [blame] | 288 | } |