1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
require_relative 'concern/observable_shared'
module Concurrent
RSpec.describe Atom do
context 'construction' do
it 'sets the initial value to the given value' do
atom = Atom.new(42)
expect(atom.value).to eq 42
end
end
context '#compare_and_set' do
it 'sets the new value if the current value matches' do
atom = Atom.new(42)
atom.compare_and_set(42, :foo)
expect(atom.value).to eq :foo
end
it 'returns true if the current value matches' do
atom = Atom.new(42)
expect(atom.compare_and_set(42, :foo)).to be true
end
it 'rejects the new value if the current value does not match' do
atom = Atom.new(42)
atom.compare_and_set(:foo, 'bar')
expect(atom.value).to eq 42
end
it 'returns false if the current value does not match' do
atom = Atom.new(42)
expect(atom.compare_and_set(:foo, 'bar')).to be false
end
it 'rejects the new value if the validator returns false' do
validator = ->(value){ false }
atom = Atom.new(42, validator: validator)
atom.compare_and_set(42, :foo)
expect(atom.value).to eq 42
end
it 'rejects the new value if the validator raises an exception' do
validator = ->(value){ raise StandardError }
atom = Atom.new(42, validator: validator)
atom.compare_and_set(42, :foo)
expect(atom.value).to eq 42
end
it 'returns false if the validator returns false' do
validator = ->(value){ false }
atom = Atom.new(42, validator: validator)
expect(atom.compare_and_set(42, :foo)).to be false
end
it 'returns false if the validator raises an exception' do
validator = ->(value){ raise StandardError }
atom = Atom.new(42, validator: validator)
expect(atom.compare_and_set(42, :foo)).to be false
end
end
context '#swap' do
it 'raises an exception when no block is given' do
atom = Atom.new(42)
expect {
atom.swap
}.to raise_error(ArgumentError)
end
it 'passes the current value to the block' do
actual = nil
expected = 42
atom = Atom.new(expected)
atom.swap do |value|
actual = value
end
expect(actual).to eq expected
end
it 'passes all arguments to the block' do
actual = nil
expected = [1, 2, 3]
atom = Atom.new(42)
atom.swap(*expected) do |value, *args|
actual = args
end
expect(actual).to eq expected
end
it 'sets the new value to the result of the block' do
atom = Atom.new(42)
atom.swap{ :foo }
expect(atom.value).to eq :foo
end
it 'rejects the new value if the validator returns false' do
validator = ->(value){ false }
atom = Atom.new(42, validator: validator)
atom.swap{ 100 }
expect(atom.value).to eq 42
end
it 'rejects the new value if the validator raises an exception' do
validator = ->(value){ raise StandardError }
atom = Atom.new(42, validator: validator)
atom.swap{ 100 }
expect(atom.value).to eq 42
end
it 'returns the new value on success' do
atom = Atom.new(42)
expect(atom.swap{ :foo }).to eq :foo
end
it 'returns the old value if the validator returns false' do
validator = ->(value){ false }
atom = Atom.new(42, validator: validator)
expect(atom.swap{ 100 }).to eq 42
end
it 'returns the old value if the validator raises an exception' do
validator = ->(value){ raise StandardError }
atom = Atom.new(42, validator: validator)
expect(atom.swap{ 100 }).to eq 42
end
it 'calls the block more than once if the value changes underneath' do
latch1 = Concurrent::CountDownLatch.new
latch2 = Concurrent::CountDownLatch.new
counter = Concurrent::AtomicFixnum.new(0)
atom = Atom.new(0)
t = in_thread do
atom.swap do |value|
latch1.count_down
latch2.wait(1)
counter.increment
42
end
end
latch1.wait(1)
atom.swap{ 100 }
latch2.count_down
t.join(1)
expect(counter.value).to be > 1
end
it 'reraises the exception from block' do
atom = Atom.new(0)
expect do
atom.swap do |value|
fail 'something went wrong'
end
end.to raise_error 'something went wrong'
end
end
context '#reset' do
it 'sets the new value' do
atom = Atom.new(42)
atom.reset(:foo)
expect(atom.value).to eq :foo
end
it 'returns the new value on success' do
atom = Atom.new(42)
expect(atom.reset(:foo)).to eq :foo
end
it 'returns the new value on success' do
atom = Atom.new(42)
expect(atom.reset(:foo)).to eq :foo
end
it 'returns the old value if the validator returns false' do
validator = ->(value){ false }
atom = Atom.new(42, validator: validator)
expect(atom.reset(:foo)).to eq 42
end
it 'returns the old value if the validator raises an exception' do
validator = ->(value){ raise StandardError }
atom = Atom.new(42, validator: validator)
expect(atom.reset(:foo)).to eq 42
end
end
context :observable do
subject { Atom.new(0) }
def trigger_observable(observable)
observable.reset(42)
end
it_behaves_like :observable
end
end
end
|
