blob: 27fd92217eefebf6cc6bd460d7abd8d8bc7b904c [file] [log] [blame] [edit]
// Copyright 2021 The Dawn Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <gmock/gmock.h>
#include "common/RefBase.h"
namespace {
using Id = uint32_t;
enum class Action {
kReference,
kRelease,
kAssign,
kMarker,
};
struct Event {
Action action;
Id thisId = 0;
Id otherId = 0;
};
std::ostream& operator<<(std::ostream& os, const Event& event) {
switch (event.action) {
case Action::kReference:
os << "Reference " << event.thisId;
break;
case Action::kRelease:
os << "Release " << event.thisId;
break;
case Action::kAssign:
os << "Assign " << event.thisId << " <- " << event.otherId;
break;
case Action::kMarker:
os << "Marker " << event.thisId;
break;
}
return os;
}
bool operator==(const Event& a, const Event& b) {
return a.action == b.action && a.thisId == b.thisId && a.otherId == b.otherId;
}
using Events = std::vector<Event>;
struct RefTracker {
explicit constexpr RefTracker(nullptr_t) : mId(0), mEvents(nullptr) {
}
constexpr RefTracker(const RefTracker& other) = default;
RefTracker(Id id, Events* events) : mId(id), mEvents(events) {
}
void Reference() const {
mEvents->emplace_back(Event{Action::kReference, mId});
}
void Release() const {
mEvents->emplace_back(Event{Action::kRelease, mId});
}
RefTracker& operator=(const RefTracker& other) {
if (mEvents || other.mEvents) {
Events* events = mEvents ? mEvents : other.mEvents;
events->emplace_back(Event{Action::kAssign, mId, other.mId});
}
mId = other.mId;
mEvents = other.mEvents;
return *this;
}
bool operator==(const RefTracker& other) const {
return mId == other.mId;
}
bool operator!=(const RefTracker& other) const {
return mId != other.mId;
}
Id mId;
Events* mEvents;
};
struct RefTrackerTraits {
static constexpr RefTracker kNullValue{nullptr};
static void Reference(const RefTracker& handle) {
handle.Reference();
}
static void Release(const RefTracker& handle) {
handle.Release();
}
};
constexpr RefTracker RefTrackerTraits::kNullValue;
using Ref = RefBase<RefTracker, RefTrackerTraits>;
} // namespace
TEST(RefBase, Acquire) {
Events events;
RefTracker tracker1(1, &events);
RefTracker tracker2(2, &events);
Ref ref(tracker1);
events.clear();
{ ref.Acquire(tracker2); }
EXPECT_THAT(events, testing::ElementsAre(Event{Action::kRelease, 1}, // release ref
Event{Action::kAssign, 1, 2} // acquire tracker2
));
}
TEST(RefBase, Detach) {
Events events;
RefTracker tracker(1, &events);
Ref ref(tracker);
events.clear();
{ DAWN_UNUSED(ref.Detach()); }
EXPECT_THAT(events, testing::ElementsAre(Event{Action::kAssign, 1, 0} // nullify ref
));
}
TEST(RefBase, Constructor) {
Ref ref;
EXPECT_EQ(ref.Get(), RefTrackerTraits::kNullValue);
}
TEST(RefBase, ConstructDestruct) {
Events events;
RefTracker tracker(1, &events);
events.clear();
{
Ref ref(tracker);
events.emplace_back(Event{Action::kMarker, 10});
}
EXPECT_THAT(events, testing::ElementsAre(Event{Action::kReference, 1}, // reference tracker
Event{Action::kMarker, 10}, //
Event{Action::kRelease, 1} // destruct ref
));
}
TEST(RefBase, CopyConstruct) {
Events events;
RefTracker tracker(1, &events);
Ref refA(tracker);
events.clear();
{
Ref refB(refA);
events.emplace_back(Event{Action::kMarker, 10});
}
EXPECT_THAT(events, testing::ElementsAre(Event{Action::kReference, 1}, // reference tracker
Event{Action::kMarker, 10}, //
Event{Action::kRelease, 1} // destruct ref
));
}
TEST(RefBase, RefCopyAssignment) {
Events events;
RefTracker tracker1(1, &events);
RefTracker tracker2(2, &events);
Ref refA(tracker1);
Ref refB(tracker2);
events.clear();
{
Ref ref;
events.emplace_back(Event{Action::kMarker, 10});
ref = refA;
events.emplace_back(Event{Action::kMarker, 20});
ref = refB;
events.emplace_back(Event{Action::kMarker, 30});
ref = refA;
events.emplace_back(Event{Action::kMarker, 40});
}
EXPECT_THAT(events, testing::ElementsAre(Event{Action::kMarker, 10}, //
Event{Action::kReference, 1}, // reference tracker1
Event{Action::kAssign, 0, 1}, // copy tracker1
Event{Action::kMarker, 20}, //
Event{Action::kReference, 2}, // reference tracker2
Event{Action::kRelease, 1}, // release tracker1
Event{Action::kAssign, 1, 2}, // copy tracker2
Event{Action::kMarker, 30}, //
Event{Action::kReference, 1}, // reference tracker1
Event{Action::kRelease, 2}, // release tracker2
Event{Action::kAssign, 2, 1}, // copy tracker1
Event{Action::kMarker, 40}, //
Event{Action::kRelease, 1} // destruct ref
));
}
TEST(RefBase, RefMoveAssignment) {
Events events;
RefTracker tracker1(1, &events);
RefTracker tracker2(2, &events);
Ref refA(tracker1);
Ref refB(tracker2);
events.clear();
{
Ref ref;
events.emplace_back(Event{Action::kMarker, 10});
ref = std::move(refA);
events.emplace_back(Event{Action::kMarker, 20});
ref = std::move(refB);
events.emplace_back(Event{Action::kMarker, 30});
}
EXPECT_THAT(events, testing::ElementsAre(Event{Action::kMarker, 10}, //
Event{Action::kAssign, 1, 0}, // nullify refA
Event{Action::kAssign, 0, 1}, // move into ref
Event{Action::kMarker, 20}, //
Event{Action::kRelease, 1}, // release tracker1
Event{Action::kAssign, 2, 0}, // nullify refB
Event{Action::kAssign, 1, 2}, // move into ref
Event{Action::kMarker, 30}, //
Event{Action::kRelease, 2} // destruct ref
));
}
TEST(RefBase, RefCopyAssignmentSelf) {
Events events;
RefTracker tracker(1, &events);
Ref ref(tracker);
Ref& self = ref;
events.clear();
{
ref = self;
ref = self;
ref = self;
}
EXPECT_THAT(events, testing::ElementsAre());
}
TEST(RefBase, RefMoveAssignmentSelf) {
Events events;
RefTracker tracker(1, &events);
Ref ref(tracker);
Ref& self = ref;
events.clear();
{
ref = std::move(self);
ref = std::move(self);
ref = std::move(self);
}
EXPECT_THAT(events, testing::ElementsAre());
}
TEST(RefBase, TCopyAssignment) {
Events events;
RefTracker tracker(1, &events);
Ref ref;
events.clear();
{
ref = tracker;
ref = tracker;
ref = tracker;
}
EXPECT_THAT(events, testing::ElementsAre(Event{Action::kReference, 1}, //
Event{Action::kAssign, 0, 1}));
}
TEST(RefBase, TMoveAssignment) {
Events events;
RefTracker tracker(1, &events);
Ref ref;
events.clear();
{ ref = std::move(tracker); }
EXPECT_THAT(events, testing::ElementsAre(Event{Action::kReference, 1}, //
Event{Action::kAssign, 0, 1}));
}
TEST(RefBase, TCopyAssignmentAlternate) {
Events events;
RefTracker tracker1(1, &events);
RefTracker tracker2(2, &events);
Ref ref;
events.clear();
{
ref = tracker1;
events.emplace_back(Event{Action::kMarker, 10});
ref = tracker2;
events.emplace_back(Event{Action::kMarker, 20});
ref = tracker1;
events.emplace_back(Event{Action::kMarker, 30});
}
EXPECT_THAT(events, testing::ElementsAre(Event{Action::kReference, 1}, // reference tracker1
Event{Action::kAssign, 0, 1}, // copy tracker1
Event{Action::kMarker, 10}, //
Event{Action::kReference, 2}, // reference tracker2
Event{Action::kRelease, 1}, // release tracker1
Event{Action::kAssign, 1, 2}, // copy tracker2
Event{Action::kMarker, 20}, //
Event{Action::kReference, 1}, // reference tracker1
Event{Action::kRelease, 2}, // release tracker2
Event{Action::kAssign, 2, 1}, // copy tracker1
Event{Action::kMarker, 30}));
}