1package server
2
3import (
4	"fmt"
5	"reflect"
6	"strconv"
7	"testing"
8
9	"github.com/siddontang/goredis"
10)
11
12func TestZSet(t *testing.T) {
13	c := getTestConn()
14	defer c.Close()
15
16	key := []byte("myzset")
17
18	if n, err := goredis.Int(c.Do("zkeyexists", key)); err != nil {
19		t.Fatal(err)
20	} else if n != 0 {
21		t.Fatal(n)
22	}
23
24	if n, err := goredis.Int(c.Do("zadd", key, 3, "a", 4, "b")); err != nil {
25		t.Fatal(err)
26	} else if n != 2 {
27		t.Fatal(n)
28	}
29
30	if n, err := goredis.Int(c.Do("zkeyexists", key)); err != nil {
31		t.Fatal(err)
32	} else if n != 1 {
33		t.Fatal(n)
34	}
35
36	if n, err := goredis.Int(c.Do("zcard", key)); err != nil {
37		t.Fatal(n)
38	} else if n != 2 {
39		t.Fatal(n)
40	}
41
42	if n, err := goredis.Int(c.Do("zadd", key, 1, "a", 2, "b")); err != nil {
43		t.Fatal(err)
44	} else if n != 0 {
45		t.Fatal(n)
46	}
47
48	if n, err := goredis.Int(c.Do("zcard", key)); err != nil {
49		t.Fatal(n)
50	} else if n != 2 {
51		t.Fatal(n)
52	}
53
54	if n, err := goredis.Int(c.Do("zadd", key, 3, "c", 4, "d")); err != nil {
55		t.Fatal(err)
56	} else if n != 2 {
57		t.Fatal(n)
58	}
59
60	if n, err := goredis.Int(c.Do("zcard", key)); err != nil {
61		t.Fatal(err)
62	} else if n != 4 {
63		t.Fatal(n)
64	}
65
66	if s, err := goredis.Int(c.Do("zscore", key, "c")); err != nil {
67		t.Fatal(err)
68	} else if s != 3 {
69		t.Fatal(s)
70	}
71
72	if n, err := goredis.Int(c.Do("zrem", key, "d", "e")); err != nil {
73		t.Fatal(err)
74	} else if n != 1 {
75		t.Fatal(n)
76	}
77
78	if n, err := goredis.Int(c.Do("zcard", key)); err != nil {
79		t.Fatal(err)
80	} else if n != 3 {
81		t.Fatal(n)
82	}
83
84	if n, err := goredis.Int(c.Do("zincrby", key, 4, "c")); err != nil {
85		t.Fatal(err)
86	} else if n != 7 {
87		t.Fatal(n)
88	}
89
90	if n, err := goredis.Int(c.Do("zincrby", key, -4, "c")); err != nil {
91		t.Fatal(err)
92	} else if n != 3 {
93		t.Fatal(n)
94	}
95
96	if n, err := goredis.Int(c.Do("zincrby", key, 4, "d")); err != nil {
97		t.Fatal(err)
98	} else if n != 4 {
99		t.Fatal(n)
100	}
101
102	if n, err := goredis.Int(c.Do("zcard", key)); err != nil {
103		t.Fatal(err)
104	} else if n != 4 {
105		t.Fatal(n)
106	}
107
108	if n, err := goredis.Int(c.Do("zrem", key, "a", "b", "c", "d")); err != nil {
109		t.Fatal(err)
110	} else if n != 4 {
111		t.Fatal(n)
112	}
113
114	if n, err := goredis.Int(c.Do("zcard", key)); err != nil {
115		t.Fatal(err)
116	} else if n != 0 {
117		t.Fatal(n)
118	}
119
120}
121
122func TestZSetCount(t *testing.T) {
123	c := getTestConn()
124	defer c.Close()
125
126	key := []byte("myzset")
127	if _, err := goredis.Int(c.Do("zadd", key, 1, "a", 2, "b", 3, "c", 4, "d")); err != nil {
128		t.Fatal(err)
129	}
130
131	if n, err := goredis.Int(c.Do("zcount", key, 2, 4)); err != nil {
132		t.Fatal(err)
133	} else if n != 3 {
134		t.Fatal(n)
135	}
136
137	if n, err := goredis.Int(c.Do("zcount", key, 4, 4)); err != nil {
138		t.Fatal(err)
139	} else if n != 1 {
140		t.Fatal(n)
141	}
142
143	if n, err := goredis.Int(c.Do("zcount", key, 4, 3)); err != nil {
144		t.Fatal(err)
145	} else if n != 0 {
146		t.Fatal(n)
147	}
148
149	if n, err := goredis.Int(c.Do("zcount", key, "(2", 4)); err != nil {
150		t.Fatal(err)
151	} else if n != 2 {
152		t.Fatal(n)
153	}
154
155	if n, err := goredis.Int(c.Do("zcount", key, "2", "(4")); err != nil {
156		t.Fatal(err)
157	} else if n != 2 {
158		t.Fatal(n)
159	}
160
161	if n, err := goredis.Int(c.Do("zcount", key, "(2", "(4")); err != nil {
162		t.Fatal(err)
163	} else if n != 1 {
164		t.Fatal(n)
165	}
166
167	if n, err := goredis.Int(c.Do("zcount", key, "-inf", "+inf")); err != nil {
168		t.Fatal(err)
169	} else if n != 4 {
170		t.Fatal(n)
171	}
172
173	c.Do("zadd", key, 3, "e")
174
175	if n, err := goredis.Int(c.Do("zcount", key, "(2", "(4")); err != nil {
176		t.Fatal(err)
177	} else if n != 2 {
178		t.Fatal(n)
179	}
180
181	c.Do("zrem", key, "a", "b", "c", "d", "e")
182}
183
184func TestZSetRank(t *testing.T) {
185	c := getTestConn()
186	defer c.Close()
187
188	key := []byte("myzset")
189	if _, err := goredis.Int(c.Do("zadd", key, 1, "a", 2, "b", 3, "c", 4, "d")); err != nil {
190		t.Fatal(err)
191	}
192
193	if n, err := goredis.Int(c.Do("zrank", key, "c")); err != nil {
194		t.Fatal(err)
195	} else if n != 2 {
196		t.Fatal(n)
197	}
198
199	if _, err := goredis.Int(c.Do("zrank", key, "e")); err != goredis.ErrNil {
200		t.Fatal(err)
201	}
202
203	if n, err := goredis.Int(c.Do("zrevrank", key, "c")); err != nil {
204		t.Fatal(err)
205	} else if n != 1 {
206		t.Fatal(n)
207	}
208
209	if _, err := goredis.Int(c.Do("zrevrank", key, "e")); err != goredis.ErrNil {
210		t.Fatal(err)
211	}
212}
213
214func testZSetRange(ay []interface{}, checkValues ...interface{}) error {
215	if len(ay) != len(checkValues) {
216		return fmt.Errorf("invalid return number %d != %d", len(ay), len(checkValues))
217	}
218
219	for i := 0; i < len(ay); i++ {
220		v, ok := ay[i].([]byte)
221		if !ok {
222			return fmt.Errorf("invalid data %d %v %T", i, ay[i], ay[i])
223		}
224
225		switch cv := checkValues[i].(type) {
226		case string:
227			if string(v) != cv {
228				return fmt.Errorf("not equal %s != %s", v, checkValues[i])
229			}
230		default:
231			if s, _ := strconv.Atoi(string(v)); s != checkValues[i] {
232				return fmt.Errorf("not equal %s != %v", v, checkValues[i])
233			}
234		}
235
236	}
237
238	return nil
239}
240
241func TestZSetRangeScore(t *testing.T) {
242	c := getTestConn()
243	defer c.Close()
244
245	key := []byte("myzset_range")
246	if _, err := goredis.Int(c.Do("zadd", key, 1, "a", 2, "b", 3, "c", 4, "d")); err != nil {
247		t.Fatal(err)
248	}
249
250	if v, err := goredis.MultiBulk(c.Do("zrangebyscore", key, 1, 4, "withscores")); err != nil {
251		t.Fatal(err)
252	} else {
253		if err := testZSetRange(v, "a", 1, "b", 2, "c", 3, "d", 4); err != nil {
254			t.Fatal(err)
255		}
256	}
257
258	if v, err := goredis.MultiBulk(c.Do("zrangebyscore", key, 1, 4, "withscores", "limit", 1, 2)); err != nil {
259		t.Fatal(err)
260	} else {
261		if err := testZSetRange(v, "b", 2, "c", 3); err != nil {
262			t.Fatal(err)
263		}
264	}
265
266	if v, err := goredis.MultiBulk(c.Do("zrangebyscore", key, "-inf", "+inf", "withscores")); err != nil {
267		t.Fatal(err)
268	} else {
269		if err := testZSetRange(v, "a", 1, "b", 2, "c", 3, "d", 4); err != nil {
270			t.Fatal(err)
271		}
272	}
273
274	if v, err := goredis.MultiBulk(c.Do("zrangebyscore", key, "(1", "(4")); err != nil {
275		t.Fatal(err)
276	} else {
277		if err := testZSetRange(v, "b", "c"); err != nil {
278			t.Fatal(err)
279		}
280	}
281
282	if v, err := goredis.MultiBulk(c.Do("zrevrangebyscore", key, 4, 1, "withscores")); err != nil {
283		t.Fatal(err)
284	} else {
285		if err := testZSetRange(v, "d", 4, "c", 3, "b", 2, "a", 1); err != nil {
286			t.Fatal(err)
287		}
288	}
289
290	if v, err := goredis.MultiBulk(c.Do("zrevrangebyscore", key, 4, 1, "withscores", "limit", 1, 2)); err != nil {
291		t.Fatal(err)
292	} else {
293		if err := testZSetRange(v, "c", 3, "b", 2); err != nil {
294			t.Fatal(err)
295		}
296	}
297
298	if v, err := goredis.MultiBulk(c.Do("zrevrangebyscore", key, "+inf", "-inf", "withscores")); err != nil {
299		t.Fatal(err)
300	} else {
301		if err := testZSetRange(v, "d", 4, "c", 3, "b", 2, "a", 1); err != nil {
302			t.Fatal(err)
303		}
304	}
305
306	if v, err := goredis.MultiBulk(c.Do("zrevrangebyscore", key, "(4", "(1")); err != nil {
307		t.Fatal(err)
308	} else {
309		if err := testZSetRange(v, "c", "b"); err != nil {
310			t.Fatal(err)
311		}
312	}
313
314	if n, err := goredis.Int(c.Do("zremrangebyscore", key, 2, 3)); err != nil {
315		t.Fatal(err)
316	} else if n != 2 {
317		t.Fatal(n)
318	}
319
320	if n, err := goredis.Int(c.Do("zcard", key)); err != nil {
321		t.Fatal(err)
322	} else if n != 2 {
323		t.Fatal(n)
324	}
325
326	if v, err := goredis.MultiBulk(c.Do("zrangebyscore", key, 1, 4)); err != nil {
327		t.Fatal(err)
328	} else {
329		if err := testZSetRange(v, "a", "d"); err != nil {
330			t.Fatal(err)
331		}
332	}
333}
334
335func TestZSetRange(t *testing.T) {
336	c := getTestConn()
337	defer c.Close()
338
339	key := []byte("myzset_range_rank")
340	if _, err := goredis.Int(c.Do("zadd", key, 1, "a", 2, "b", 3, "c", 4, "d")); err != nil {
341		t.Fatal(err)
342	}
343
344	if v, err := goredis.MultiBulk(c.Do("zrange", key, 0, 3, "withscores")); err != nil {
345		t.Fatal(err)
346	} else {
347		if err := testZSetRange(v, "a", 1, "b", 2, "c", 3, "d", 4); err != nil {
348			t.Fatal(err)
349		}
350	}
351
352	if v, err := goredis.MultiBulk(c.Do("zrange", key, 1, 4, "withscores")); err != nil {
353		t.Fatal(err)
354	} else {
355		if err := testZSetRange(v, "b", 2, "c", 3, "d", 4); err != nil {
356			t.Fatal(err)
357		}
358	}
359
360	if v, err := goredis.MultiBulk(c.Do("zrange", key, -2, -1, "withscores")); err != nil {
361		t.Fatal(err)
362	} else {
363		if err := testZSetRange(v, "c", 3, "d", 4); err != nil {
364			t.Fatal(err)
365		}
366	}
367
368	if v, err := goredis.MultiBulk(c.Do("zrange", key, 0, -1, "withscores")); err != nil {
369		t.Fatal(err)
370	} else {
371		if err := testZSetRange(v, "a", 1, "b", 2, "c", 3, "d", 4); err != nil {
372			t.Fatal(err)
373		}
374	}
375
376	if v, err := goredis.MultiBulk(c.Do("zrange", key, -1, -2, "withscores")); err != nil {
377		t.Fatal(err)
378	} else if len(v) != 0 {
379		t.Fatal(len(v))
380	}
381
382	if v, err := goredis.MultiBulk(c.Do("zrevrange", key, 0, 4, "withscores")); err != nil {
383		t.Fatal(err)
384	} else {
385		if err := testZSetRange(v, "d", 4, "c", 3, "b", 2, "a", 1); err != nil {
386			t.Fatal(err)
387		}
388	}
389
390	if v, err := goredis.MultiBulk(c.Do("zrevrange", key, 0, -1, "withscores")); err != nil {
391		t.Fatal(err)
392	} else {
393		if err := testZSetRange(v, "d", 4, "c", 3, "b", 2, "a", 1); err != nil {
394			t.Fatal(err)
395		}
396	}
397
398	if v, err := goredis.MultiBulk(c.Do("zrevrange", key, 2, 3, "withscores")); err != nil {
399		t.Fatal(err)
400	} else {
401		if err := testZSetRange(v, "b", 2, "a", 1); err != nil {
402			t.Fatal(err)
403		}
404	}
405
406	if v, err := goredis.MultiBulk(c.Do("zrevrange", key, -2, -1, "withscores")); err != nil {
407		t.Fatal(err)
408	} else {
409		if err := testZSetRange(v, "b", 2, "a", 1); err != nil {
410			t.Fatal(err)
411		}
412	}
413
414	if n, err := goredis.Int(c.Do("zremrangebyrank", key, 2, 3)); err != nil {
415		t.Fatal(err)
416	} else if n != 2 {
417		t.Fatal(n)
418	}
419
420	if n, err := goredis.Int(c.Do("zcard", key)); err != nil {
421		t.Fatal(err)
422	} else if n != 2 {
423		t.Fatal(n)
424	}
425
426	if v, err := goredis.MultiBulk(c.Do("zrange", key, 0, 4)); err != nil {
427		t.Fatal(err)
428	} else {
429		if err := testZSetRange(v, "a", "b"); err != nil {
430			t.Fatal(err)
431		}
432	}
433
434	if n, err := goredis.Int(c.Do("zclear", key)); err != nil {
435		t.Fatal(err)
436	} else if n != 2 {
437		t.Fatal(n)
438	}
439
440	if n, err := goredis.Int(c.Do("zcard", key)); err != nil {
441		t.Fatal(err)
442	} else if n != 0 {
443		t.Fatal(n)
444	}
445
446}
447
448func TestZsetErrorParams(t *testing.T) {
449	c := getTestConn()
450	defer c.Close()
451
452	//zadd
453	if _, err := c.Do("zadd", "test_zadd"); err == nil {
454		t.Fatalf("invalid err of %v", err)
455	}
456
457	if _, err := c.Do("zadd", "test_zadd", "a", "b", "c"); err == nil {
458		t.Fatalf("invalid err of %v", err)
459	}
460
461	if _, err := c.Do("zadd", "test_zadd", "-a", "a"); err == nil {
462		t.Fatalf("invalid err of %v", err)
463	}
464
465	if _, err := c.Do("zadd", "test_zad", "0.1", "a"); err == nil {
466		t.Fatalf("invalid err of %v", err)
467	}
468
469	//zcard
470	if _, err := c.Do("zcard"); err == nil {
471		t.Fatalf("invalid err of %v", err)
472	}
473
474	//zscore
475	if _, err := c.Do("zscore", "test_zscore"); err == nil {
476		t.Fatalf("invalid err of %v", err)
477	}
478
479	//zrem
480	if _, err := c.Do("zrem", "test_zrem"); err == nil {
481		t.Fatalf("invalid err of %v", err)
482	}
483
484	//zincrby
485	if _, err := c.Do("zincrby", "test_zincrby"); err == nil {
486		t.Fatalf("invalid err of %v", err)
487	}
488
489	if _, err := c.Do("zincrby", "test_zincrby", 0.1, "a"); err == nil {
490		t.Fatalf("invalid err of %v", err)
491	}
492
493	//zcount
494	if _, err := c.Do("zcount", "test_zcount"); err == nil {
495		t.Fatalf("invalid err of %v", err)
496	}
497
498	if _, err := c.Do("zcount", "test_zcount", "-inf", "=inf"); err == nil {
499		t.Fatalf("invalid err of %v", err)
500	}
501
502	if _, err := c.Do("zcount", "test_zcount", 0.1, 0.1); err == nil {
503		t.Fatalf("invalid err of %v", err)
504	}
505
506	//zrank
507	if _, err := c.Do("zrank", "test_zrank"); err == nil {
508		t.Fatalf("invalid err of %v", err)
509	}
510
511	//zrevzrank
512	if _, err := c.Do("zrevrank", "test_zrevrank"); err == nil {
513		t.Fatalf("invalid err of %v", err)
514	}
515
516	//zremrangebyrank
517	if _, err := c.Do("zremrangebyrank", "test_zremrangebyrank"); err == nil {
518		t.Fatalf("invalid err of %v", err)
519	}
520
521	if _, err := c.Do("zremrangebyrank", "test_zremrangebyrank", 0.1, 0.1); err == nil {
522		t.Fatalf("invalid err of %v", err)
523	}
524
525	//zremrangebyscore
526	if _, err := c.Do("zremrangebyscore", "test_zremrangebyscore"); err == nil {
527		t.Fatalf("invalid err of %v", err)
528	}
529
530	if _, err := c.Do("zremrangebyscore", "test_zremrangebyscore", "-inf", "a"); err == nil {
531		t.Fatalf("invalid err of %v", err)
532	}
533
534	if _, err := c.Do("zremrangebyscore", "test_zremrangebyscore", 0, "a"); err == nil {
535		t.Fatalf("invalid err of %v", err)
536	}
537
538	//zrange
539	if _, err := c.Do("zrange", "test_zrange"); err == nil {
540		t.Fatalf("invalid err of %v", err)
541	}
542
543	if _, err := c.Do("zrange", "test_zrange", 0, 1, "withscore"); err == nil {
544		t.Fatalf("invalid err of %v", err)
545	}
546
547	if _, err := c.Do("zrange", "test_zrange", 0, 1, "withscores", "a"); err == nil {
548		t.Fatalf("invalid err of %v", err)
549	}
550
551	//zrevrange, almost same as zrange
552	if _, err := c.Do("zrevrange", "test_zrevrange"); err == nil {
553		t.Fatalf("invalid err of %v", err)
554	}
555
556	//zrangebyscore
557	if _, err := c.Do("zrangebyscore", "test_zrangebyscore"); err == nil {
558		t.Fatalf("invalid err of %v", err)
559	}
560
561	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscore"); err == nil {
562		t.Fatalf("invalid err of %v", err)
563	}
564
565	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limit"); err == nil {
566		t.Fatalf("invalid err of %v", err)
567	}
568
569	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limi", 1, 1); err == nil {
570		t.Fatalf("invalid err of %v", err)
571	}
572
573	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limit", "a", 1); err == nil {
574		t.Fatalf("invalid err of %v", err)
575	}
576
577	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limit", 1, "a"); err == nil {
578		t.Fatalf("invalid err of %v", err)
579	}
580
581	//zrevrangebyscore, almost same as zrangebyscore
582	if _, err := c.Do("zrevrangebyscore", "test_zrevrangebyscore"); err == nil {
583		t.Fatalf("invalid err of %v", err)
584	}
585
586	//zclear
587	if _, err := c.Do("zclear"); err == nil {
588		t.Fatalf("invalid err of %v", err)
589	}
590
591	//zmclear
592	if _, err := c.Do("zmclear"); err == nil {
593		t.Fatalf("invalid err of %v", err)
594	}
595
596	//zexpire
597	if _, err := c.Do("zexpire", "test_zexpire"); err == nil {
598		t.Fatalf("invalid err of %v", err)
599	}
600
601	//zexpireat
602	if _, err := c.Do("zexpireat", "test_zexpireat"); err == nil {
603		t.Fatalf("invalid err of %v", err)
604	}
605
606	//zttl
607	if _, err := c.Do("zttl"); err == nil {
608		t.Fatalf("invalid err of %v", err)
609	}
610
611	//zpersist
612	if _, err := c.Do("zpersist"); err == nil {
613		t.Fatalf("invalid err of %v", err)
614	}
615
616}
617
618func TestZUnionStore(t *testing.T) {
619	c := getTestConn()
620	defer c.Close()
621
622	if _, err := c.Do("zadd", "k1", "1", "one"); err != nil {
623		t.Fatal(err.Error())
624	}
625
626	if _, err := c.Do("zadd", "k1", "2", "two"); err != nil {
627		t.Fatal(err.Error())
628	}
629
630	if _, err := c.Do("zadd", "k2", "1", "two"); err != nil {
631		t.Fatal(err.Error())
632	}
633
634	if _, err := c.Do("zadd", "k2", "2", "three"); err != nil {
635		t.Fatal(err.Error())
636	}
637
638	if n, err := goredis.Int64(c.Do("zunionstore", "out", "2", "k1", "k2", "weights", "1", "2")); err != nil {
639		t.Fatal(err.Error())
640	} else {
641		if n != 3 {
642			t.Fatal("invalid value ", n)
643		}
644	}
645
646	if n, err := goredis.Int64(c.Do("zunionstore", "out", "2", "k1", "k2", "weights", "1", "2", "aggregate", "min")); err != nil {
647		t.Fatal(err.Error())
648	} else {
649		if n != 3 {
650			t.Fatal("invalid value ", n)
651		}
652	}
653
654	if n, err := goredis.Int64(c.Do("zunionstore", "out", "2", "k1", "k2", "aggregate", "max")); err != nil {
655		t.Fatal(err.Error())
656	} else {
657		if n != 3 {
658			t.Fatal("invalid value ", n)
659		}
660	}
661
662	if n, err := goredis.Int64(c.Do("zscore", "out", "two")); err != nil {
663		t.Fatal(err.Error())
664	} else {
665		if n != 2 {
666			t.Fatal("invalid value ", n)
667		}
668	}
669}
670
671func TestZInterStore(t *testing.T) {
672	c := getTestConn()
673	defer c.Close()
674
675	if _, err := c.Do("zadd", "k1", "1", "one"); err != nil {
676		t.Fatal(err.Error())
677	}
678
679	if _, err := c.Do("zadd", "k1", "2", "two"); err != nil {
680		t.Fatal(err.Error())
681	}
682
683	if _, err := c.Do("zadd", "k2", "1", "two"); err != nil {
684		t.Fatal(err.Error())
685	}
686
687	if _, err := c.Do("zadd", "k2", "2", "three"); err != nil {
688		t.Fatal(err.Error())
689	}
690
691	if n, err := goredis.Int64(c.Do("zinterstore", "out", "2", "k1", "k2", "weights", "1", "2")); err != nil {
692		t.Fatal(err.Error())
693	} else {
694		if n != 1 {
695			t.Fatal("invalid value ", n)
696		}
697	}
698
699	if n, err := goredis.Int64(c.Do("zinterstore", "out", "2", "k1", "k2", "aggregate", "min", "weights", "1", "2")); err != nil {
700		t.Fatal(err.Error())
701	} else {
702		if n != 1 {
703			t.Fatal("invalid value ", n)
704		}
705	}
706
707	if n, err := goredis.Int64(c.Do("zinterstore", "out", "2", "k1", "k2", "aggregate", "sum")); err != nil {
708		t.Fatal(err.Error())
709	} else {
710		if n != 1 {
711			t.Fatal("invalid value ", n)
712		}
713	}
714
715	if n, err := goredis.Int64(c.Do("zscore", "out", "two")); err != nil {
716		t.Fatal(err.Error())
717	} else {
718		if n != 3 {
719			t.Fatal("invalid value ", n)
720		}
721	}
722
723	if _, err := c.Do("zadd", "k3", "3", "three"); err != nil {
724		t.Fatal(err.Error())
725	}
726
727	if n, err := goredis.Int64(c.Do("zinterstore", "out", "3", "k1", "k2", "k3", "aggregate", "sum")); err != nil {
728		t.Fatal(err.Error())
729	} else {
730		if n != 0 {
731			t.Fatal("invalid value ", n)
732		}
733	}
734
735	if _, err := c.Do("zadd", "k3", "3", "two"); err != nil {
736		t.Fatal(err.Error())
737	}
738
739	if n, err := goredis.Int64(c.Do("zinterstore", "out", "3", "k1", "k2", "k3", "aggregate", "sum", "weights", "3", "2", "2")); err != nil {
740		t.Fatal(err.Error())
741	} else {
742		if n != 1 {
743			t.Fatal("invalid value ", n)
744		}
745	}
746
747	if n, err := goredis.Int64(c.Do("zscore", "out", "two")); err != nil {
748		t.Fatal(err.Error())
749	} else {
750		if n != 14 {
751			t.Fatal("invalid value ", n)
752		}
753	}
754}
755
756func TestZSetLex(t *testing.T) {
757	c := getTestConn()
758	defer c.Close()
759
760	key := []byte("myzlexset")
761	if _, err := c.Do("zadd", key,
762		0, "a", 0, "b", 0, "c", 0, "d", 0, "e", 0, "f", 0, "g"); err != nil {
763		t.Fatal(err)
764	}
765
766	if ay, err := goredis.Strings(c.Do("zrangebylex", key, "-", "[c")); err != nil {
767		t.Fatal(err)
768	} else if !reflect.DeepEqual(ay, []string{"a", "b", "c"}) {
769		t.Fatal("must equal")
770	}
771
772	if ay, err := goredis.Strings(c.Do("zrangebylex", key, "-", "(c")); err != nil {
773		t.Fatal(err)
774	} else if !reflect.DeepEqual(ay, []string{"a", "b"}) {
775		t.Fatal("must equal")
776	}
777
778	if ay, err := goredis.Strings(c.Do("zrangebylex", key, "[aaa", "(g")); err != nil {
779		t.Fatal(err)
780	} else if !reflect.DeepEqual(ay, []string{"b", "c", "d", "e", "f"}) {
781		t.Fatal("must equal")
782	}
783
784	if n, err := goredis.Int64(c.Do("zlexcount", key, "-", "(c")); err != nil {
785		t.Fatal(err)
786	} else if n != 2 {
787		t.Fatal(n)
788	}
789
790	if n, err := goredis.Int64(c.Do("zremrangebylex", key, "[aaa", "(g")); err != nil {
791		t.Fatal(err)
792	} else if n != 5 {
793		t.Fatal(n)
794	}
795
796	if n, err := goredis.Int64(c.Do("zlexcount", key, "-", "+")); err != nil {
797		t.Fatal(err)
798	} else if n != 2 {
799		t.Fatal(n)
800	}
801
802}
803