toad.city
That fuck shit the fascists are using
1package org.tm.archive.database
2
3import androidx.test.ext.junit.runners.AndroidJUnit4
4import junit.framework.Assert.assertFalse
5import junit.framework.Assert.assertTrue
6import org.junit.Before
7import org.junit.Test
8import org.junit.runner.RunWith
9import org.signal.core.util.concurrent.SignalExecutors
10import java.util.concurrent.CountDownLatch
11import java.util.concurrent.atomic.AtomicBoolean
12
13/**
14 * These are tests for the wrapper we wrote around SQLCipherDatabase, not the stock or SQLCipher one.
15 */
16@RunWith(AndroidJUnit4::class)
17class SQLiteDatabaseTest {
18
19 private lateinit var db: SQLiteDatabase
20
21 @Before
22 fun setup() {
23 db = SignalDatabase.instance!!.signalWritableDatabase
24 }
25
26 @Test
27 fun runPostSuccessfulTransaction_runsImmediatelyIfNotInTransaction() {
28 val hasRun = AtomicBoolean(false)
29 db.runPostSuccessfulTransaction { hasRun.set(true) }
30 assertTrue(hasRun.get())
31 }
32
33 @Test
34 fun runPostSuccessfulTransaction_runsAfterSuccessIfInTransaction() {
35 val hasRun = AtomicBoolean(false)
36
37 db.beginTransaction()
38
39 db.runPostSuccessfulTransaction { hasRun.set(true) }
40 assertFalse(hasRun.get())
41
42 db.setTransactionSuccessful()
43 db.endTransaction()
44
45 assertTrue(hasRun.get())
46 }
47
48 @Test
49 fun runPostSuccessfulTransaction_doesNotRunAfterFailedTransaction() {
50 val hasRun = AtomicBoolean(false)
51
52 db.beginTransaction()
53
54 db.runPostSuccessfulTransaction { hasRun.set(true) }
55 assertFalse(hasRun.get())
56
57 db.endTransaction()
58
59 assertFalse(hasRun.get())
60
61 // Verifying we still don't run it even after a subsequent success
62 db.beginTransaction()
63 db.setTransactionSuccessful()
64 db.endTransaction()
65
66 assertFalse(hasRun.get())
67 }
68
69 @Test
70 fun runPostSuccessfulTransaction_onlyRunAfterAllTransactionsComplete() {
71 val hasRun = AtomicBoolean(false)
72
73 db.beginTransaction()
74
75 db.runPostSuccessfulTransaction { hasRun.set(true) }
76 assertFalse(hasRun.get())
77
78 db.beginTransaction()
79 db.setTransactionSuccessful()
80 db.endTransaction()
81 assertFalse(hasRun.get())
82
83 db.setTransactionSuccessful()
84 db.endTransaction()
85
86 assertTrue(hasRun.get())
87 }
88
89 @Test
90 fun runPostSuccessfulTransaction_runsImmediatelyIfTheTransactionIsOnAnotherThread() {
91 db.beginTransaction()
92
93 val latch = CountDownLatch(1)
94 SignalExecutors.BOUNDED.execute {
95 val hasRun = AtomicBoolean(false)
96 db.runPostSuccessfulTransaction { hasRun.set(true) }
97 assertTrue(hasRun.get())
98 latch.countDown()
99 }
100
101 latch.await()
102
103 db.setTransactionSuccessful()
104 db.endTransaction()
105 }
106
107 @Test
108 fun runPostSuccessfulTransaction_runsAfterSuccessIfInTransaction_ignoreDuplicates() {
109 val hasRun1 = AtomicBoolean(false)
110 val hasRun2 = AtomicBoolean(false)
111
112 db.beginTransaction()
113
114 db.runPostSuccessfulTransaction("key") { hasRun1.set(true) }
115 db.runPostSuccessfulTransaction("key") { hasRun2.set(true) }
116 assertFalse(hasRun1.get())
117 assertFalse(hasRun2.get())
118
119 db.setTransactionSuccessful()
120 db.endTransaction()
121
122 assertTrue(hasRun1.get())
123 assertFalse(hasRun2.get())
124 }
125
126 @Test
127 fun runPostSuccessfulTransaction_runsAndPerformsAnotherTransaction() {
128 val hasRun = AtomicBoolean(false)
129
130 db.beginTransaction()
131
132 db.runPostSuccessfulTransaction {
133 try {
134 db.beginTransaction()
135 hasRun.set(true)
136 db.setTransactionSuccessful()
137 } finally {
138 db.endTransaction()
139 }
140 }
141
142 assertFalse(hasRun.get())
143
144 db.setTransactionSuccessful()
145 db.endTransaction()
146
147 assertTrue(hasRun.get())
148 }
149
150 @Test
151 fun runPostSuccessfulTransaction_runsAndPerformsAnotherTransactionAndRunPostNested() {
152 val hasRun1 = AtomicBoolean(false)
153 val hasRun2 = AtomicBoolean(false)
154
155 db.beginTransaction()
156
157 db.runPostSuccessfulTransaction {
158 db.beginTransaction()
159
160 db.runPostSuccessfulTransaction {
161 assertTrue(hasRun1.get())
162 assertFalse(hasRun2.get())
163 hasRun2.set(true)
164 }
165
166 assertFalse(hasRun1.get())
167 hasRun1.set(true)
168 assertFalse(hasRun2.get())
169
170 db.setTransactionSuccessful()
171 db.endTransaction()
172 }
173
174 assertFalse(hasRun1.get())
175 assertFalse(hasRun2.get())
176
177 db.setTransactionSuccessful()
178 db.endTransaction()
179
180 assertTrue(hasRun1.get())
181 assertTrue(hasRun2.get())
182 }
183
184 @Test
185 fun runPostSuccessfulTransaction_runsAfterMainTransactionInNestedTransaction() {
186 val hasRun1 = AtomicBoolean(false)
187 val hasRun2 = AtomicBoolean(false)
188
189 db.beginTransaction()
190
191 db.runPostSuccessfulTransaction {
192 assertFalse(hasRun1.get())
193 assertFalse(hasRun2.get())
194 hasRun1.set(true)
195 }
196
197 assertFalse(hasRun1.get())
198 assertFalse(hasRun2.get())
199
200 db.beginTransaction()
201
202 db.runPostSuccessfulTransaction {
203 assertTrue(hasRun1.get())
204 assertFalse(hasRun2.get())
205 hasRun2.set(true)
206 }
207
208 db.setTransactionSuccessful()
209
210 assertFalse(hasRun1.get())
211 assertFalse(hasRun2.get())
212
213 db.endTransaction()
214 db.setTransactionSuccessful()
215
216 assertFalse(hasRun1.get())
217 assertFalse(hasRun2.get())
218
219 db.endTransaction()
220
221 assertTrue(hasRun1.get())
222 assertTrue(hasRun2.get())
223 }
224}