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
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
start_server {tags {"incr"}} {
test {INCR against non existing key} {
set res {}
append res [r incr novar]
append res [r get novar]
} {11}
test {INCR against key created by incr itself} {
r incr novar
} {2}
test {DECR against key created by incr} {
r decr novar
} {1}
test {DECR against key is not exist and incr} {
r del novar_not_exist
assert_equal {-1} [r decr novar_not_exist]
assert_equal {0} [r incr novar_not_exist]
}
test {INCR against key originally set with SET} {
r set novar 100
r incr novar
} {101}
test {INCR over 32bit value} {
r set novar 17179869184
r incr novar
} {17179869185}
test {INCRBY over 32bit value with over 32bit increment} {
r set novar 17179869184
r incrby novar 17179869184
} {34359738368}
test {INCR fails against key with spaces (left)} {
r set novar " 11"
catch {r incr novar} err
format $err
} {ERR*}
test {INCR fails against key with spaces (right)} {
r set novar "11 "
catch {r incr novar} err
format $err
} {ERR*}
test {INCR fails against key with spaces (both)} {
r set novar " 11 "
catch {r incr novar} err
format $err
} {ERR*}
test {DECRBY negation overflow} {
r set x 0
catch {r decrby x -9223372036854775808} err
format $err
} {ERR*}
test {INCR fails against a key holding a list} {
r rpush mylist 1
catch {r incr mylist} err
r rpop mylist
format $err
} {WRONGTYPE*}
test {DECRBY over 32bit value with over 32bit increment, negative res} {
r set novar 17179869184
r decrby novar 17179869185
} {-1}
test {DECRBY against key is not exist} {
r del key_not_exist
assert_equal {-1} [r decrby key_not_exist 1]
}
test {INCR uses shared objects in the 0-9999 range} {
r set foo -1
r incr foo
assert_refcount_morethan foo 1
r set foo 9998
r incr foo
assert_refcount_morethan foo 1
r incr foo
assert_refcount 1 foo
}
test {INCR can modify objects in-place} {
r set foo 20000
r incr foo
assert_refcount 1 foo
set old [lindex [split [r debug object foo]] 1]
r incr foo
set new [lindex [split [r debug object foo]] 1]
assert {[string range $old 0 2] eq "at:"}
assert {[string range $new 0 2] eq "at:"}
assert {$old eq $new}
} {} {needs:debug}
test {INCRBYFLOAT against non existing key} {
r del novar
list [roundFloat [r incrbyfloat novar 1]] \
[roundFloat [r get novar]] \
[roundFloat [r incrbyfloat novar 0.25]] \
[roundFloat [r get novar]]
} {1 1 1.25 1.25}
test {INCRBYFLOAT against key originally set with SET} {
r set novar 1.5
roundFloat [r incrbyfloat novar 1.5]
} {3}
test {INCRBYFLOAT over 32bit value} {
r set novar 17179869184
r incrbyfloat novar 1.5
} {17179869185.5}
test {INCRBYFLOAT over 32bit value with over 32bit increment} {
r set novar 17179869184
r incrbyfloat novar 17179869184
} {34359738368}
test {INCRBYFLOAT fails against key with spaces (left)} {
set err {}
r set novar " 11"
catch {r incrbyfloat novar 1.0} err
format $err
} {ERR *valid*}
test {INCRBYFLOAT fails against key with spaces (right)} {
set err {}
r set novar "11 "
catch {r incrbyfloat novar 1.0} err
format $err
} {ERR *valid*}
test {INCRBYFLOAT fails against key with spaces (both)} {
set err {}
r set novar " 11 "
catch {r incrbyfloat novar 1.0} err
format $err
} {ERR *valid*}
test {INCRBYFLOAT fails against a key holding a list} {
r del mylist
set err {}
r rpush mylist 1
catch {r incrbyfloat mylist 1.0} err
r del mylist
format $err
} {WRONGTYPE*}
# On some platforms strtold("+inf") with valgrind returns a non-inf result
if {!$::valgrind} {
test {INCRBYFLOAT does not allow NaN or Infinity} {
r set foo 0
set err {}
catch {r incrbyfloat foo +inf} err
set err
# p.s. no way I can force NaN to test it from the API because
# there is no way to increment / decrement by infinity nor to
# perform divisions.
} {ERR *would produce*}
}
test {INCRBYFLOAT decrement} {
r set foo 1
roundFloat [r incrbyfloat foo -1.1]
} {-0.1}
test {string to double with null terminator} {
r set foo 1
r setrange foo 2 2
catch {r incrbyfloat foo 1} err
format $err
} {ERR *valid*}
test {No negative zero} {
r del foo
r incrbyfloat foo [expr double(1)/41]
r incrbyfloat foo [expr double(-1)/41]
r get foo
} {0}
test {INCRBY INCRBYFLOAT DECRBY against unhappy path} {
r del mykeyincr
assert_error "*ERR wrong number of arguments*" {r incr mykeyincr v}
assert_error "*ERR wrong number of arguments*" {r decr mykeyincr v}
assert_error "*value is not an integer or out of range*" {r incrby mykeyincr v}
assert_error "*value is not an integer or out of range*" {r incrby mykeyincr 1.5}
assert_error "*value is not an integer or out of range*" {r decrby mykeyincr v}
assert_error "*value is not an integer or out of range*" {r decrby mykeyincr 1.5}
assert_error "*value is not a valid float*" {r incrbyfloat mykeyincr v}
}
foreach cmd {"incr" "decr" "incrby" "decrby"} {
test "$cmd operation should update encoding from raw to int" {
set res {}
set expected {1 12}
if {[string match {*incr*} $cmd]} {
lappend expected 13
} else {
lappend expected 11
}
r set foo 1
assert_encoding "int" foo
lappend res [r get foo]
r append foo 2
assert_encoding "raw" foo
lappend res [r get foo]
if {[string match {*by*} $cmd]} {
r $cmd foo 1
} else {
r $cmd foo
}
assert_encoding "int" foo
lappend res [r get foo]
assert_equal $res $expected
}
}
}
|
