OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 The Crashpad Authors. All rights reserved. |
| 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. |
| 14 |
| 15 #include "util/file/file_reader.h" |
| 16 |
| 17 #include <stdint.h> |
| 18 |
| 19 #include <limits> |
| 20 #include <type_traits> |
| 21 |
| 22 #include "gmock/gmock.h" |
| 23 #include "gtest/gtest.h" |
| 24 |
| 25 namespace crashpad { |
| 26 namespace test { |
| 27 namespace { |
| 28 |
| 29 using testing::_; |
| 30 using testing::InSequence; |
| 31 using testing::Return; |
| 32 |
| 33 class MockFileReader : public FileReaderInterface { |
| 34 public: |
| 35 MockFileReader() : FileReaderInterface() {} |
| 36 ~MockFileReader() override {} |
| 37 |
| 38 // Since it’s more convenient for the test to use uintptr_t than void*, |
| 39 // ReadExactlyInt() and ReadInt() adapt the types. |
| 40 |
| 41 bool ReadExactlyInt(uintptr_t data, size_t size) { |
| 42 return ReadExactly(reinterpret_cast<void*>(data), size); |
| 43 } |
| 44 |
| 45 MOCK_METHOD2(ReadInt, FileOperationResult(uintptr_t, size_t)); |
| 46 |
| 47 // FileReaderInterface: |
| 48 FileOperationResult Read(void* data, size_t size) { |
| 49 return ReadInt(reinterpret_cast<uintptr_t>(data), size); |
| 50 } |
| 51 |
| 52 // FileSeekerInterface: |
| 53 MOCK_METHOD2(Seek, FileOffset(FileOffset, int)); |
| 54 |
| 55 private: |
| 56 DISALLOW_COPY_AND_ASSIGN(MockFileReader); |
| 57 }; |
| 58 |
| 59 TEST(FileReader, ReadExactly_Zero) { |
| 60 MockFileReader file_reader; |
| 61 InSequence in_sequence; |
| 62 EXPECT_CALL(file_reader, ReadInt(_, _)).Times(0); |
| 63 EXPECT_CALL(file_reader, Seek(_, _)).Times(0); |
| 64 EXPECT_TRUE(file_reader.ReadExactlyInt(100, 0)); |
| 65 } |
| 66 |
| 67 TEST(FileReader, ReadExactly_SingleSmallSuccess) { |
| 68 MockFileReader file_reader; |
| 69 InSequence in_sequence; |
| 70 EXPECT_CALL(file_reader, ReadInt(1000, 1)).WillOnce(Return(1)); |
| 71 EXPECT_CALL(file_reader, Seek(_, _)).Times(0); |
| 72 EXPECT_TRUE(file_reader.ReadExactlyInt(1000, 1)); |
| 73 } |
| 74 |
| 75 TEST(FileReader, ReadExactly_SingleSmallFailure) { |
| 76 MockFileReader file_reader; |
| 77 InSequence in_sequence; |
| 78 EXPECT_CALL(file_reader, ReadInt(1000, 1)).WillOnce(Return(-1)); |
| 79 EXPECT_CALL(file_reader, Seek(_, _)).Times(0); |
| 80 EXPECT_FALSE(file_reader.ReadExactlyInt(1000, 1)); |
| 81 } |
| 82 |
| 83 TEST(FileReader, ReadExactly_DoubleSmallSuccess) { |
| 84 MockFileReader file_reader; |
| 85 InSequence in_sequence; |
| 86 EXPECT_CALL(file_reader, ReadInt(0x1000, 2)).WillOnce(Return(1)); |
| 87 EXPECT_CALL(file_reader, ReadInt(0x1001, 1)).WillOnce(Return(1)); |
| 88 EXPECT_CALL(file_reader, Seek(_, _)).Times(0); |
| 89 EXPECT_TRUE(file_reader.ReadExactlyInt(0x1000, 2)); |
| 90 } |
| 91 |
| 92 TEST(FileReader, ReadExactly_DoubleSmallShort) { |
| 93 MockFileReader file_reader; |
| 94 InSequence in_sequence; |
| 95 EXPECT_CALL(file_reader, ReadInt(0x20000, 2)).WillOnce(Return(1)); |
| 96 EXPECT_CALL(file_reader, ReadInt(0x20001, 1)).WillOnce(Return(0)); |
| 97 EXPECT_CALL(file_reader, Seek(_, _)).Times(0); |
| 98 EXPECT_FALSE(file_reader.ReadExactlyInt(0x20000, 2)); |
| 99 } |
| 100 |
| 101 TEST(FileReader, ReadExactly_Medium) { |
| 102 MockFileReader file_reader; |
| 103 InSequence in_sequence; |
| 104 EXPECT_CALL(file_reader, ReadInt(0x80000000, 0x20000000)) |
| 105 .WillOnce(Return(0x10000000)); |
| 106 EXPECT_CALL(file_reader, ReadInt(0x90000000, 0x10000000)) |
| 107 .WillOnce(Return(0x8000000)); |
| 108 EXPECT_CALL(file_reader, ReadInt(0x98000000, 0x8000000)) |
| 109 .WillOnce(Return(0x4000000)); |
| 110 EXPECT_CALL(file_reader, ReadInt(0x9c000000, 0x4000000)) |
| 111 .WillOnce(Return(0x2000000)); |
| 112 EXPECT_CALL(file_reader, ReadInt(0x9e000000, 0x2000000)) |
| 113 .WillOnce(Return(0x1000000)); |
| 114 EXPECT_CALL(file_reader, ReadInt(0x9f000000, 0x1000000)) |
| 115 .WillOnce(Return(0x800000)); |
| 116 EXPECT_CALL(file_reader, ReadInt(0x9f800000, 0x800000)) |
| 117 .WillOnce(Return(0x400000)); |
| 118 EXPECT_CALL(file_reader, ReadInt(0x9fc00000, 0x400000)) |
| 119 .WillOnce(Return(0x200000)); |
| 120 EXPECT_CALL(file_reader, ReadInt(0x9fe00000, 0x200000)) |
| 121 .WillOnce(Return(0x100000)); |
| 122 EXPECT_CALL(file_reader, ReadInt(0x9ff00000, 0x100000)) |
| 123 .WillOnce(Return(0x80000)); |
| 124 EXPECT_CALL(file_reader, ReadInt(0x9ff80000, 0x80000)) |
| 125 .WillOnce(Return(0x40000)); |
| 126 EXPECT_CALL(file_reader, ReadInt(0x9ffc0000, 0x40000)) |
| 127 .WillOnce(Return(0x20000)); |
| 128 EXPECT_CALL(file_reader, ReadInt(0x9ffe0000, 0x20000)) |
| 129 .WillOnce(Return(0x10000)); |
| 130 EXPECT_CALL(file_reader, ReadInt(0x9fff0000, 0x10000)) |
| 131 .WillOnce(Return(0x8000)); |
| 132 EXPECT_CALL(file_reader, ReadInt(0x9fff8000, 0x8000)) |
| 133 .WillOnce(Return(0x4000)); |
| 134 EXPECT_CALL(file_reader, ReadInt(0x9fffc000, 0x4000)) |
| 135 .WillOnce(Return(0x2000)); |
| 136 EXPECT_CALL(file_reader, ReadInt(0x9fffe000, 0x2000)) |
| 137 .WillOnce(Return(0x1000)); |
| 138 EXPECT_CALL(file_reader, ReadInt(0x9ffff000, 0x1000)).WillOnce(Return(0x800)); |
| 139 EXPECT_CALL(file_reader, ReadInt(0x9ffff800, 0x800)).WillOnce(Return(0x400)); |
| 140 EXPECT_CALL(file_reader, ReadInt(0x9ffffc00, 0x400)).WillOnce(Return(0x200)); |
| 141 EXPECT_CALL(file_reader, ReadInt(0x9ffffe00, 0x200)).WillOnce(Return(0x100)); |
| 142 EXPECT_CALL(file_reader, ReadInt(0x9fffff00, 0x100)).WillOnce(Return(0x80)); |
| 143 EXPECT_CALL(file_reader, ReadInt(0x9fffff80, 0x80)).WillOnce(Return(0x40)); |
| 144 EXPECT_CALL(file_reader, ReadInt(0x9fffffc0, 0x40)).WillOnce(Return(0x20)); |
| 145 EXPECT_CALL(file_reader, ReadInt(0x9fffffe0, 0x20)).WillOnce(Return(0x10)); |
| 146 EXPECT_CALL(file_reader, ReadInt(0x9ffffff0, 0x10)).WillOnce(Return(0x8)); |
| 147 EXPECT_CALL(file_reader, ReadInt(0x9ffffff8, 0x8)).WillOnce(Return(0x4)); |
| 148 EXPECT_CALL(file_reader, ReadInt(0x9ffffffc, 0x4)).WillOnce(Return(0x2)); |
| 149 EXPECT_CALL(file_reader, ReadInt(0x9ffffffe, 0x2)).WillOnce(Return(0x1)); |
| 150 EXPECT_CALL(file_reader, ReadInt(0x9fffffff, 0x1)).WillOnce(Return(0x1)); |
| 151 EXPECT_CALL(file_reader, Seek(_, _)).Times(0); |
| 152 EXPECT_TRUE(file_reader.ReadExactlyInt(0x80000000, 0x20000000)); |
| 153 } |
| 154 |
| 155 TEST(FileReader, ReadExactly_LargeSuccess) { |
| 156 MockFileReader file_reader; |
| 157 InSequence in_sequence; |
| 158 constexpr size_t max = std::numeric_limits<uint32_t>::max(); |
| 159 constexpr size_t increment = std::numeric_limits<int32_t>::max(); |
| 160 EXPECT_CALL(file_reader, ReadInt(0, max)).WillOnce(Return(increment)); |
| 161 EXPECT_CALL(file_reader, ReadInt(increment, max - increment)) |
| 162 .WillOnce(Return(increment)); |
| 163 EXPECT_CALL(file_reader, ReadInt(2 * increment, 1)).WillOnce(Return(1)); |
| 164 EXPECT_CALL(file_reader, Seek(_, _)).Times(0); |
| 165 EXPECT_TRUE(file_reader.ReadExactlyInt(0, max)); |
| 166 } |
| 167 |
| 168 TEST(FileReader, ReadExactly_LargeShort) { |
| 169 MockFileReader file_reader; |
| 170 InSequence in_sequence; |
| 171 EXPECT_CALL(file_reader, ReadInt(0, 0xffffffff)).WillOnce(Return(0x7fffffff)); |
| 172 EXPECT_CALL(file_reader, ReadInt(0x7fffffff, 0x80000000)) |
| 173 .WillOnce(Return(0x10000000)); |
| 174 EXPECT_CALL(file_reader, ReadInt(0x8fffffff, 0x70000000)).WillOnce(Return(0)); |
| 175 EXPECT_CALL(file_reader, Seek(_, _)).Times(0); |
| 176 EXPECT_FALSE(file_reader.ReadExactlyInt(0, 0xffffffff)); |
| 177 } |
| 178 |
| 179 TEST(FileReader, ReadExactly_LargeFailure) { |
| 180 MockFileReader file_reader; |
| 181 InSequence in_sequence; |
| 182 EXPECT_CALL(file_reader, ReadInt(0, 0xffffffff)).WillOnce(Return(0x7fffffff)); |
| 183 EXPECT_CALL(file_reader, ReadInt(0x7fffffff, 0x80000000)) |
| 184 .WillOnce(Return(-1)); |
| 185 EXPECT_CALL(file_reader, Seek(_, _)).Times(0); |
| 186 EXPECT_FALSE(file_reader.ReadExactlyInt(0, 0xffffffff)); |
| 187 } |
| 188 |
| 189 TEST(FileReader, ReadExactly_TripleMax) { |
| 190 MockFileReader file_reader; |
| 191 InSequence in_sequence; |
| 192 constexpr size_t max = std::numeric_limits<size_t>::max(); |
| 193 constexpr size_t increment = |
| 194 std::numeric_limits<std::make_signed<size_t>::type>::max(); |
| 195 EXPECT_CALL(file_reader, ReadInt(0, max)).WillOnce(Return(increment)); |
| 196 EXPECT_CALL(file_reader, ReadInt(increment, max - increment)) |
| 197 .WillOnce(Return(increment)); |
| 198 EXPECT_CALL(file_reader, ReadInt(2 * increment, 1)).WillOnce(Return(1)); |
| 199 EXPECT_CALL(file_reader, Seek(_, _)).Times(0); |
| 200 EXPECT_TRUE(file_reader.ReadExactlyInt(0, max)); |
| 201 } |
| 202 |
| 203 } // namespace |
| 204 } // namespace test |
| 205 } // namespace crashpad |
OLD | NEW |