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
|
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 {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 {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 {INCR uses shared objects in the 0-9999 range} {
r set foo -1
r incr foo
assert {[r object refcount foo] > 1}
r set foo 9998
r incr foo
assert {[r object refcount foo] > 1}
r incr foo
assert {[r object refcount foo] == 1}
}
test {INCR can modify objects in-place} {
r set foo 20000
r incr foo
assert {[r object refcount foo] == 1}
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}
}
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}
}
|
