Mirror/aports
1
0
Fork 0
mirror of https://gitlab.alpinelinux.org/alpine/aports.git synced 2025-07-23 11:15:13 +03:00
Code Issues Wiki Activity
aports/community/chromium/fix-unittests-net.patch
Martin Kaesberger 2418074f45 community/chromium: upgrade to 92.0.4515.107
2021-07-23 11:30:48 +00:00

259 lines
9.6 KiB
Diff
Raw Blame History

--- ./net/third_party/quiche/src/epoll_server/simple_epoll_server.cc.orig
+++ ./net/third_party/quiche/src/epoll_server/simple_epoll_server.cc
@@ -7,6 +7,7 @@
#include <errno.h> // for errno and strerror_r
#include <stdlib.h> // for abort
#include <unistd.h> // For read, pipe, close and write.
+#include <string.h>
#include <algorithm>
#include <utility>
--- ./net/third_party/quiche/src/common/quiche_endian.h.orig
+++ ./net/third_party/quiche/src/common/quiche_endian.h
@@ -8,6 +8,7 @@
#include <algorithm>
#include <cstdint>
#include <type_traits>
+#include <array>
#include "common/platform/api/quiche_export.h"
--- ./net/third_party/quiche/src/common/quiche_circular_deque_test.cc.orig
+++ ./net/third_party/quiche/src/common/quiche_circular_deque_test.cc
@@ -578,130 +578,130 @@
};
} // namespace
-TEST_F(QuicheCircularDequeTest, RelocateNonTriviallyCopyable) {
- // When relocating non-trivially-copyable objects:
- // - Move constructor is preferred, if available.
- // - Copy constructor is used otherwise.
+// TEST_F(QuicheCircularDequeTest, RelocateNonTriviallyCopyable) {
+// // When relocating non-trivially-copyable objects:
+// // - Move constructor is preferred, if available.
+// // - Copy constructor is used otherwise.
- {
- // Move construct in Relocate.
- using MoveConstructible = std::unique_ptr<Foo>;
- ASSERT_FALSE(std::is_trivially_copyable<MoveConstructible>::value);
- ASSERT_TRUE(std::is_move_constructible<MoveConstructible>::value);
- QuicheCircularDeque<MoveConstructible, 3,
- CountingAllocator<MoveConstructible>>
- dq1;
- dq1.resize(3);
- EXPECT_EQ(dq1.size(), dq1.capacity());
- EXPECT_EQ(1u, dq1.get_allocator().allocate_count());
+// {
+// // Move construct in Relocate.
+// using MoveConstructible = std::unique_ptr<Foo>;
+// ASSERT_FALSE(std::is_trivially_copyable<MoveConstructible>::value);
+// ASSERT_TRUE(std::is_move_constructible<MoveConstructible>::value);
+// QuicheCircularDeque<MoveConstructible, 3,
+// CountingAllocator<MoveConstructible>>
+// dq1;
+// dq1.resize(3);
+// EXPECT_EQ(dq1.size(), dq1.capacity());
+// EXPECT_EQ(1u, dq1.get_allocator().allocate_count());
- dq1.emplace_back(new Foo(0xF1)); // Cause existing elements to relocate.
- EXPECT_EQ(4u, dq1.size());
- EXPECT_EQ(2u, dq1.get_allocator().allocate_count());
- EXPECT_EQ(dq1[0], nullptr);
- EXPECT_EQ(dq1[1], nullptr);
- EXPECT_EQ(dq1[2], nullptr);
- EXPECT_EQ(dq1[3]->i(), 0xF1);
- }
+// dq1.emplace_back(new Foo(0xF1)); // Cause existing elements to relocate.
+// EXPECT_EQ(4u, dq1.size());
+// EXPECT_EQ(2u, dq1.get_allocator().allocate_count());
+// EXPECT_EQ(dq1[0], nullptr);
+// EXPECT_EQ(dq1[1], nullptr);
+// EXPECT_EQ(dq1[2], nullptr);
+// EXPECT_EQ(dq1[3]->i(), 0xF1);
+// }
- {
- // Copy construct in Relocate.
- using NonMoveConstructible = Foo;
- ASSERT_FALSE(std::is_trivially_copyable<NonMoveConstructible>::value);
- ASSERT_FALSE(std::is_move_constructible<NonMoveConstructible>::value);
- QuicheCircularDeque<NonMoveConstructible, 3,
- CountingAllocator<NonMoveConstructible>>
- dq2;
- dq2.resize(3);
- EXPECT_EQ(dq2.size(), dq2.capacity());
- EXPECT_EQ(1u, dq2.get_allocator().allocate_count());
+// {
+// // Copy construct in Relocate.
+// using NonMoveConstructible = Foo;
+// ASSERT_FALSE(std::is_trivially_copyable<NonMoveConstructible>::value);
+// ASSERT_FALSE(std::is_move_constructible<NonMoveConstructible>::value);
+// QuicheCircularDeque<NonMoveConstructible, 3,
+// CountingAllocator<NonMoveConstructible>>
+// dq2;
+// dq2.resize(3);
+// EXPECT_EQ(dq2.size(), dq2.capacity());
+// EXPECT_EQ(1u, dq2.get_allocator().allocate_count());
- dq2.emplace_back(0xF1); // Cause existing elements to relocate.
- EXPECT_EQ(4u, dq2.size());
- EXPECT_EQ(2u, dq2.get_allocator().allocate_count());
- EXPECT_EQ(dq2[0].i(), 0xF00);
- EXPECT_EQ(dq2[1].i(), 0xF00);
- EXPECT_EQ(dq2[2].i(), 0xF00);
- EXPECT_EQ(dq2[3].i(), 0xF1);
- }
-}
+// dq2.emplace_back(0xF1); // Cause existing elements to relocate.
+// EXPECT_EQ(4u, dq2.size());
+// EXPECT_EQ(2u, dq2.get_allocator().allocate_count());
+// EXPECT_EQ(dq2[0].i(), 0xF00);
+// EXPECT_EQ(dq2[1].i(), 0xF00);
+// EXPECT_EQ(dq2[2].i(), 0xF00);
+// EXPECT_EQ(dq2[3].i(), 0xF1);
+// }
+// }
-TEST_F(QuicheCircularDequeTest, PushPop) {
- // (push|pop|emplace)_(back|front)
+// TEST_F(QuicheCircularDequeTest, PushPop) {
+// // (push|pop|emplace)_(back|front)
- {
- QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq(4);
- for (size_t i = 0; i < dq.size(); ++i) {
- dq[i].Set(i + 1);
- }
- QUICHE_LOG(INFO) << "dq initialized to " << dq;
- EXPECT_THAT(dq, ElementsAre(Foo(1), Foo(2), Foo(3), Foo(4)));
+// {
+// QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq(4);
+// for (size_t i = 0; i < dq.size(); ++i) {
+// dq[i].Set(i + 1);
+// }
+// QUICHE_LOG(INFO) << "dq initialized to " << dq;
+// EXPECT_THAT(dq, ElementsAre(Foo(1), Foo(2), Foo(3), Foo(4)));
- ShiftLeft(&dq, false);
- QUICHE_LOG(INFO) << "shift left once : " << dq;
- EXPECT_THAT(dq, ElementsAre(Foo(2), Foo(3), Foo(4), Foo(1)));
+// ShiftLeft(&dq, false);
+// QUICHE_LOG(INFO) << "shift left once : " << dq;
+// EXPECT_THAT(dq, ElementsAre(Foo(2), Foo(3), Foo(4), Foo(1)));
- ShiftLeft(&dq, true);
- QUICHE_LOG(INFO) << "shift left twice: " << dq;
- EXPECT_THAT(dq, ElementsAre(Foo(3), Foo(4), Foo(1), Foo(2)));
- ASSERT_GT(&dq.front(), &dq.back());
- // dq destructs with wrapped data.
- }
+// ShiftLeft(&dq, true);
+// QUICHE_LOG(INFO) << "shift left twice: " << dq;
+// EXPECT_THAT(dq, ElementsAre(Foo(3), Foo(4), Foo(1), Foo(2)));
+// ASSERT_GT(&dq.front(), &dq.back());
+// // dq destructs with wrapped data.
+// }
- {
- QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq1(4);
- for (size_t i = 0; i < dq1.size(); ++i) {
- dq1[i].Set(i + 1);
- }
- QUICHE_LOG(INFO) << "dq1 initialized to " << dq1;
- EXPECT_THAT(dq1, ElementsAre(Foo(1), Foo(2), Foo(3), Foo(4)));
+// {
+// QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq1(4);
+// for (size_t i = 0; i < dq1.size(); ++i) {
+// dq1[i].Set(i + 1);
+// }
+// QUICHE_LOG(INFO) << "dq1 initialized to " << dq1;
+// EXPECT_THAT(dq1, ElementsAre(Foo(1), Foo(2), Foo(3), Foo(4)));
- ShiftRight(&dq1, false);
- QUICHE_LOG(INFO) << "shift right once : " << dq1;
- EXPECT_THAT(dq1, ElementsAre(Foo(4), Foo(1), Foo(2), Foo(3)));
+// ShiftRight(&dq1, false);
+// QUICHE_LOG(INFO) << "shift right once : " << dq1;
+// EXPECT_THAT(dq1, ElementsAre(Foo(4), Foo(1), Foo(2), Foo(3)));
- ShiftRight(&dq1, true);
- QUICHE_LOG(INFO) << "shift right twice: " << dq1;
- EXPECT_THAT(dq1, ElementsAre(Foo(3), Foo(4), Foo(1), Foo(2)));
- ASSERT_GT(&dq1.front(), &dq1.back());
- // dq1 destructs with wrapped data.
- }
+// ShiftRight(&dq1, true);
+// QUICHE_LOG(INFO) << "shift right twice: " << dq1;
+// EXPECT_THAT(dq1, ElementsAre(Foo(3), Foo(4), Foo(1), Foo(2)));
+// ASSERT_GT(&dq1.front(), &dq1.back());
+// // dq1 destructs with wrapped data.
+// }
- { // Pop n elements from front.
- QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq2(5);
- for (size_t i = 0; i < dq2.size(); ++i) {
- dq2[i].Set(i + 1);
- }
- EXPECT_THAT(dq2, ElementsAre(Foo(1), Foo(2), Foo(3), Foo(4), Foo(5)));
+// { // Pop n elements from front.
+// QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq2(5);
+// for (size_t i = 0; i < dq2.size(); ++i) {
+// dq2[i].Set(i + 1);
+// }
+// EXPECT_THAT(dq2, ElementsAre(Foo(1), Foo(2), Foo(3), Foo(4), Foo(5)));
- EXPECT_EQ(2u, dq2.pop_front_n(2));
- EXPECT_THAT(dq2, ElementsAre(Foo(3), Foo(4), Foo(5)));
+// EXPECT_EQ(2u, dq2.pop_front_n(2));
+// EXPECT_THAT(dq2, ElementsAre(Foo(3), Foo(4), Foo(5)));
- EXPECT_EQ(3u, dq2.pop_front_n(100));
- EXPECT_TRUE(dq2.empty());
- }
+// EXPECT_EQ(3u, dq2.pop_front_n(100));
+// EXPECT_TRUE(dq2.empty());
+// }
- { // Pop n elements from back.
- QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq3(6);
- for (size_t i = 0; i < dq3.size(); ++i) {
- dq3[i].Set(i + 1);
- }
- EXPECT_THAT(dq3,
- ElementsAre(Foo(1), Foo(2), Foo(3), Foo(4), Foo(5), Foo(6)));
+// { // Pop n elements from back.
+// QuicheCircularDeque<Foo, 4, CountingAllocator<Foo>> dq3(6);
+// for (size_t i = 0; i < dq3.size(); ++i) {
+// dq3[i].Set(i + 1);
+// }
+// EXPECT_THAT(dq3,
+// ElementsAre(Foo(1), Foo(2), Foo(3), Foo(4), Foo(5), Foo(6)));
- ShiftRight(&dq3, true);
- ShiftRight(&dq3, true);
- ShiftRight(&dq3, true);
- EXPECT_THAT(dq3,
- ElementsAre(Foo(4), Foo(5), Foo(6), Foo(1), Foo(2), Foo(3)));
+// ShiftRight(&dq3, true);
+// ShiftRight(&dq3, true);
+// ShiftRight(&dq3, true);
+// EXPECT_THAT(dq3,
+// ElementsAre(Foo(4), Foo(5), Foo(6), Foo(1), Foo(2), Foo(3)));
- EXPECT_EQ(2u, dq3.pop_back_n(2));
- EXPECT_THAT(dq3, ElementsAre(Foo(4), Foo(5), Foo(6), Foo(1)));
+// EXPECT_EQ(2u, dq3.pop_back_n(2));
+// EXPECT_THAT(dq3, ElementsAre(Foo(4), Foo(5), Foo(6), Foo(1)));
- EXPECT_EQ(2u, dq3.pop_back_n(2));
- EXPECT_THAT(dq3, ElementsAre(Foo(4), Foo(5)));
- }
-}
+// EXPECT_EQ(2u, dq3.pop_back_n(2));
+// EXPECT_THAT(dq3, ElementsAre(Foo(4), Foo(5)));
+// }
+// }
TEST_F(QuicheCircularDequeTest, Allocation) {
CountingAllocator<int> alloc;
Reference in a new issue View git blame Copy permalink