Blender V5.3
sound_reader_cache_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
6
7#include "testing/testing.h"
8
9#if defined(WITH_AUDASPACE)
10
11# include <memory>
12# include <utility>
13
14# include <IReader.h>
15# include <ISound.h>
16# include <util/Buffer.h>
17# include <util/StreamBuffer.h>
18
19namespace blender::bke::tests {
20
21struct ReaderControl {
22 int readers_created = 0;
23 int live_readers = 0;
24};
25
26class CountingSound : public aud::ISound {
27 private:
28 std::shared_ptr<aud::ISound> sound;
29
30 public:
31 std::shared_ptr<ReaderControl> control = std::make_shared<ReaderControl>();
32
33 explicit CountingSound(std::shared_ptr<aud::ISound> sound) : sound(std::move(sound)) {}
34
35 std::shared_ptr<aud::IReader> createReader() override
36 {
37 this->control->readers_created++;
38 std::shared_ptr<aud::IReader> reader = this->sound->createReader();
39 this->control->live_readers++;
40 aud::IReader *reader_pointer = reader.get();
41 return std::shared_ptr<aud::IReader>(
42 reader_pointer,
43 [reader = std::move(reader), control = this->control](aud::IReader *) mutable {
44 reader.reset();
45 control->live_readers--;
46 });
47 }
48};
49
50static std::shared_ptr<CountingSound> create_test_sound()
51{
52 auto buffer = std::make_shared<aud::Buffer>(sizeof(aud::sample_t));
53 auto stream = std::make_shared<aud::StreamBuffer>(
54 buffer, aud::Specs{aud::RATE_48000, aud::CHANNELS_MONO});
55 return std::make_shared<CountingSound>(std::move(stream));
56}
57
58TEST(sound_reader_cache, ReusesReaderAndLimitsIdleReaders)
59{
60 const std::shared_ptr<CountingSound> sound = create_test_sound();
61 SoundReaderCache cache(sound);
62
63 {
64 SoundReaderLease lease = cache.acquire();
65 ASSERT_TRUE(lease);
66 }
67 {
68 SoundReaderLease lease = cache.acquire();
69 ASSERT_TRUE(lease);
70 }
71 EXPECT_EQ(sound->control->readers_created, 1);
72
73 SoundReaderLease first = cache.acquire();
74 SoundReaderLease second = cache.acquire();
75 SoundReaderLease third = cache.acquire();
76 ASSERT_TRUE(first);
77 ASSERT_TRUE(second);
78 ASSERT_TRUE(third);
79 EXPECT_EQ(sound->control->readers_created, 3);
80
81 first = {};
82 second = {};
83 third = {};
84 EXPECT_EQ(sound->control->live_readers, 2);
85
86 SoundReaderLease reused_first = cache.acquire();
87 SoundReaderLease reused_second = cache.acquire();
88 ASSERT_TRUE(reused_first);
89 ASSERT_TRUE(reused_second);
90 EXPECT_EQ(sound->control->readers_created, 3);
91}
92
93TEST(sound_reader_cache, DiscardDestroysReader)
94{
95 const std::shared_ptr<CountingSound> sound = create_test_sound();
96 SoundReaderCache cache(sound);
97 {
98 SoundReaderLease lease = cache.acquire();
99 ASSERT_TRUE(lease);
100 lease.discard();
101 EXPECT_FALSE(lease);
102 }
103 EXPECT_EQ(sound->control->live_readers, 0);
104
105 SoundReaderLease replacement = cache.acquire();
106 ASSERT_TRUE(replacement);
107 EXPECT_EQ(sound->control->readers_created, 2);
108}
109
110TEST(sound_reader_cache, MoveOperationsReturnEachReaderOnce)
111{
112 const std::shared_ptr<CountingSound> sound = create_test_sound();
113 SoundReaderCache cache(sound);
114 SoundReaderLease first = cache.acquire();
115 ASSERT_TRUE(first);
116
117 SoundReaderLease moved(std::move(first));
118 EXPECT_FALSE(first);
119 SoundReaderLease second = cache.acquire();
120 ASSERT_TRUE(second);
121 moved = std::move(second);
122 EXPECT_FALSE(second);
123
124 moved = {};
125 SoundReaderLease reused_first = cache.acquire();
126 SoundReaderLease reused_second = cache.acquire();
127 ASSERT_TRUE(reused_first);
128 ASSERT_TRUE(reused_second);
129 EXPECT_EQ(sound->control->readers_created, 2);
130}
131
132TEST(sound_reader_cache, LeaseOutlivesCache)
133{
134 const std::shared_ptr<CountingSound> sound = create_test_sound();
135 auto cache = std::make_shared<SoundReaderCache>(sound);
136 SoundReaderLease lease = cache->acquire();
137 ASSERT_TRUE(lease);
138
139 cache.reset();
140 EXPECT_EQ(sound->control->live_readers, 1);
141 lease = {};
142 EXPECT_EQ(sound->control->live_readers, 0);
143}
144
145} // namespace blender::bke::tests
146
147#endif
#define EXPECT_FALSE(result)
#define EXPECT_EQ(result, expect)
TEST(mat3_vec_to_roll, UnitMatrix)