redismodule/tst/src/exstrings_test.cpp

   1 /*
   2  * Copyright (c) 2018-2019 Nokia.
   3  *
   4  *   Licensed under the Apache License, Version 2.0 (the "License");
   5  *   you may not use this file except in compliance with the License.
   6  *   You may obtain a copy of the License at
   7  *
   8  *       http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *   Unless required by applicable law or agreed to in writing, software
  11  *   distributed under the License is distributed on an "AS IS" BASIS,
  12  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *   See the License for the specific language governing permissions and
  14  *   limitations under the License.
  15  */
  16
  17 #include <string>
  18 #include <map>
  19 #include <list>
  20 #include <set>
  21 #include <vector>
  22 #include <syslog.h>
  23
  24
  25 //#include <stdio.h>
  26 //#include <stdlib.h>
  27 //#include <ctype.h>
  28
  29
  30 extern "C" {
  31 #include "exstringsStub.h"
  32 #include "redismodule.h"
  33 }
  34
  35 #include "CppUTest/TestHarness.h"
  36 #include "CppUTestExt/MockSupport.h"
  37
  38 #define OBJ_OP_NO 0
  39 #define OBJ_OP_XX (1<<1)     /* OP if key exist */
  40 #define OBJ_OP_NX (1<<2)     /* OP if key not exist */
  41 #define OBJ_OP_IE (1<<4)     /* OP if equal old value */
  42 #define OBJ_OP_NE (1<<5)     /* OP if not equal old value */
  43
  44
  45 TEST_GROUP(exstring)
  46 {
  47     void setup()
  48     {
  49
  50         mock().enable();
  51         mock().ignoreOtherCalls();
  52     }
  53
  54     void teardown()
  55     {
  56         mock().clear();
  57         mock().disable();
  58     }
  59
  60 };
  61
  62 TEST(exstring, OnLoad)
  63 {
  64     RedisModuleCtx ctx;
  65     int ret = RedisModule_OnLoad(&ctx, 0, 0);
  66     CHECK_EQUAL(ret, 0);
  67 }
  68
  69 TEST(exstring, setie)
  70 {
  71     RedisModuleCtx ctx;
  72     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
  73
  74     redisStrVec[0] = (RedisModuleString *)1;
  75     redisStrVec[1] = (RedisModuleString *)1;
  76     redisStrVec[2] = (RedisModuleString *)1;
  77     redisStrVec[3] = (RedisModuleString *)1;
  78
  79     mock().setData("RedisModule_OpenKey_have", 1);
  80     mock().setData("RedisModule_KeyType_str", 1);
  81     mock().setData("RedisModule_String_same", 1);
  82     mock().setData("RedisModule_CallReplyType_null", 1);
  83
  84     int ret = SetIE_RedisCommand(&ctx, redisStrVec,  4);
  85     CHECK_EQUAL(ret, 0);
  86     delete []redisStrVec;
  87 }
  88
  89 TEST(exstring, setne)
  90 {
  91     RedisModuleCtx ctx;
  92     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
  93
  94     redisStrVec[0] = (RedisModuleString *)1;
  95     redisStrVec[1] = (RedisModuleString *)1;
  96     redisStrVec[2] = (RedisModuleString *)1;
  97     redisStrVec[3] = (RedisModuleString *)1;
  98
  99     mock().setData("RedisModule_OpenKey_have", 1);
 100     mock().setData("RedisModule_KeyType_str", 1);
 101     mock().setData("RedisModule_String_same", 1);
 102     int ret = SetNE_RedisCommand(&ctx,redisStrVec, 4);
 103     CHECK_EQUAL(ret, 0);
 104     delete []redisStrVec;
 105 }
 106
 107 TEST(exstring, command_parameter_number_incorrect)
 108 {
 109     RedisModuleCtx ctx;
 110     int ret = setStringGenericCommand(&ctx, 0, 3, OBJ_OP_IE);
 111     CHECK_EQUAL(ret, 1);
 112 }
 113
 114
 115 TEST(exstring, setie_command_no_key)
 116 {
 117     RedisModuleCtx ctx;
 118     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
 119
 120     redisStrVec[0] = (RedisModuleString *)1;
 121     redisStrVec[1] = (RedisModuleString *)1;
 122     redisStrVec[2] = (RedisModuleString *)1;
 123     redisStrVec[3] = (RedisModuleString *)1;
 124     mock().setData("RedisModule_OpenKey_no", 1);
 125
 126     int ret = setStringGenericCommand(&ctx, redisStrVec, 4, OBJ_OP_IE);
 127     CHECK_EQUAL(ret, 0);
 128     delete []redisStrVec;
 129
 130 }
 131
 132
 133 TEST(exstring, setie_command_has_key_set)
 134 {
 135     RedisModuleCtx ctx;
 136     //RedisModuleString str;
 137     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
 138
 139     redisStrVec[0] = (RedisModuleString *)1;
 140     redisStrVec[1] = (RedisModuleString *)1;
 141     redisStrVec[2] = (RedisModuleString *)1;
 142     redisStrVec[3] = (RedisModuleString *)1;
 143
 144     mock().setData("RedisModule_OpenKey_have", 1);
 145     mock().setData("RedisModule_KeyType_set", 1);
 146     int ret = setStringGenericCommand(&ctx, redisStrVec, 4, OBJ_OP_IE);
 147     CHECK_EQUAL(ret, REDISMODULE_OK);
 148     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
 149     delete []redisStrVec;
 150
 151 }
 152
 153 TEST(exstring, setie_command_key_string_nosame)
 154 {
 155     RedisModuleCtx ctx;
 156     //RedisModuleString str;
 157     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
 158
 159     redisStrVec[0] = (RedisModuleString *)1;
 160     redisStrVec[1] = (RedisModuleString *)1;
 161     redisStrVec[2] = (RedisModuleString *)1;
 162     redisStrVec[3] = (RedisModuleString *)1;
 163
 164     mock().setData("RedisModule_OpenKey_have", 1);
 165     mock().setData("RedisModule_KeyType_str", 1);
 166
 167     mock().setData("RedisModule_String_nosame", 1);
 168
 169
 170     int ret = setStringGenericCommand(&ctx, redisStrVec, 4, OBJ_OP_IE);
 171     CHECK_EQUAL(ret, 0);
 172     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 173     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
 174     delete []redisStrVec;
 175
 176 }
 177
 178 TEST(exstring, setie_command_key_same_string_reply)
 179 {
 180     RedisModuleCtx ctx;
 181     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
 182
 183     redisStrVec[0] = (RedisModuleString *)1;
 184     redisStrVec[1] = (RedisModuleString *)1;
 185     redisStrVec[2] = (RedisModuleString *)1;
 186     redisStrVec[3] = (RedisModuleString *)1;
 187
 188     mock().setData("RedisModule_OpenKey_have", 1);
 189     mock().setData("RedisModule_KeyType_str", 1);
 190     mock().setData("RedisModule_String_same", 1);
 191     mock().setData("RedisModule_CallReplyType_null", 1);
 192
 193     int ret = setStringGenericCommand(&ctx, redisStrVec, 4, OBJ_OP_IE);
 194     CHECK_EQUAL(ret, 0);
 195     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 196     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
 197     delete []redisStrVec;
 198 }
 199
 200
 201
 202 TEST(exstring, setne_command_key_string_same_replrstr)
 203 {
 204     RedisModuleCtx ctx;
 205     //RedisModuleString str;
 206     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
 207
 208     redisStrVec[0] = (RedisModuleString *)1;
 209     redisStrVec[1] = (RedisModuleString *)1;
 210     redisStrVec[2] = (RedisModuleString *)1;
 211     redisStrVec[3] = (RedisModuleString *)1;
 212
 213     mock().setData("RedisModule_OpenKey_have", 1);
 214     mock().setData("RedisModule_KeyType_str", 1);
 215     mock().setData("RedisModule_String_same", 1);
 216     //mock().setData("RedisModule_CallReplyType_str", 1);
 217
 218     int ret = setStringGenericCommand(&ctx, redisStrVec, 4, OBJ_OP_NE);
 219     CHECK_EQUAL(ret, 0);
 220     delete []redisStrVec;
 221
 222 }
 223
 224 TEST(exstring, setne_command_setne_key_string_nosame_replrstr)
 225 {
 226     RedisModuleCtx ctx;
 227     //RedisModuleString str;
 228     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
 229
 230     redisStrVec[0] = (RedisModuleString *)1;
 231     redisStrVec[1] = (RedisModuleString *)1;
 232     redisStrVec[2] = (RedisModuleString *)1;
 233     redisStrVec[3] = (RedisModuleString *)1;
 234
 235     mock().setData("RedisModule_OpenKey_have", 1);
 236     mock().setData("RedisModule_KeyType_str", 1);
 237     mock().setData("RedisModule_String_nosame", 1);
 238     mock().setData("RedisModule_CallReplyType_str", 1);
 239
 240     int ret = setStringGenericCommand(&ctx, redisStrVec, 4, OBJ_OP_NE);
 241     CHECK_EQUAL(ret, 0);
 242     delete []redisStrVec;
 243
 244 }
 245
 246 TEST(exstring, delie)
 247 {
 248     RedisModuleCtx ctx;
 249     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 250
 251     redisStrVec[0] = (RedisModuleString *)1;
 252     redisStrVec[1] = (RedisModuleString *)1;
 253     redisStrVec[2] = (RedisModuleString *)1;
 254
 255     mock().setData("RedisModule_OpenKey_have", 1);
 256     mock().setData("RedisModule_KeyType_str", 1);
 257     mock().setData("RedisModule_String_same", 1);
 258     mock().setData("RedisModule_CallReplyType_null", 1);
 259
 260     mock().expectOneCall("RedisModule_CloseKey");
 261     int ret = DelIE_RedisCommand(&ctx, redisStrVec,  3);
 262     CHECK_EQUAL(ret, 0);
 263     mock().checkExpectations();
 264     delete []redisStrVec;
 265 }
 266
 267 TEST(exstring, delne)
 268 {
 269     RedisModuleCtx ctx;
 270     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 271
 272     redisStrVec[0] = (RedisModuleString *)1;
 273     redisStrVec[1] = (RedisModuleString *)1;
 274     redisStrVec[2] = (RedisModuleString *)1;
 275
 276     mock().setData("RedisModule_OpenKey_have", 1);
 277     mock().setData("RedisModule_KeyType_str", 1);
 278     mock().setData("RedisModule_String_same", 1);
 279     mock().expectOneCall("RedisModule_CloseKey");
 280     int ret = DelNE_RedisCommand(&ctx,redisStrVec, 3);
 281     CHECK_EQUAL(ret, 0);
 282     mock().checkExpectations();
 283     delete []redisStrVec;
 284 }
 285
 286 TEST(exstring, del_command_parameter_number_incorrect)
 287 {
 288     RedisModuleCtx ctx;
 289     int ret = 0;
 290     ret = delStringGenericCommand(&ctx, 0, 2, OBJ_OP_IE);
 291     CHECK_EQUAL(ret, 1);
 292
 293     ret = 0;
 294     ret = delStringGenericCommand(&ctx, 0, 4, OBJ_OP_NE);
 295     CHECK_EQUAL(ret, 1);
 296 }
 297
 298 TEST(exstring, delie_command_no_key)
 299 {
 300     RedisModuleCtx ctx;
 301     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 302
 303     redisStrVec[0] = (RedisModuleString *)1;
 304     redisStrVec[1] = (RedisModuleString *)1;
 305     redisStrVec[2] = (RedisModuleString *)1;
 306     mock().setData("RedisModule_OpenKey_no", 1);
 307
 308     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_IE);
 309     CHECK_EQUAL(ret, 0);
 310     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
 311     delete []redisStrVec;
 312
 313 }
 314
 315 TEST(exstring, delie_command_have_key_set)
 316 {
 317     RedisModuleCtx ctx;
 318     //RedisModuleString str;
 319     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 320
 321     redisStrVec[0] = (RedisModuleString *)1;
 322     redisStrVec[1] = (RedisModuleString *)1;
 323     redisStrVec[2] = (RedisModuleString *)1;
 324
 325     mock().setData("RedisModule_OpenKey_have", 1);
 326     mock().setData("RedisModule_KeyType_set", 1);
 327     mock().expectOneCall("RedisModule_CloseKey");
 328     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_IE);
 329     CHECK_EQUAL(ret, REDISMODULE_OK);
 330     mock().checkExpectations();
 331     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
 332     delete []redisStrVec;
 333 }
 334
 335 TEST(exstring, delie_command_key_string_nosame)
 336 {
 337     RedisModuleCtx ctx;
 338     //RedisModuleString str;
 339     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 340
 341     redisStrVec[0] = (RedisModuleString *)1;
 342     redisStrVec[1] = (RedisModuleString *)1;
 343     redisStrVec[2] = (RedisModuleString *)1;
 344
 345     mock().setData("RedisModule_OpenKey_have", 1);
 346     mock().setData("RedisModule_KeyType_str", 1);
 347
 348     mock().setData("RedisModule_String_nosame", 1);
 349
 350
 351     mock().expectOneCall("RedisModule_CloseKey");
 352     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_IE);
 353     CHECK_EQUAL(ret, 0);
 354     mock().checkExpectations();
 355     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 356     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
 357     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
 358     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
 359     delete []redisStrVec;
 360
 361 }
 362
 363
 364 TEST(exstring, delie_command_key_same_string_reply)
 365 {
 366     RedisModuleCtx ctx;
 367     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 368
 369     redisStrVec[0] = (RedisModuleString *)1;
 370     redisStrVec[1] = (RedisModuleString *)1;
 371     redisStrVec[2] = (RedisModuleString *)1;
 372
 373     mock().setData("RedisModule_OpenKey_have", 1);
 374     mock().setData("RedisModule_KeyType_str", 1);
 375     mock().setData("RedisModule_String_same", 1);
 376     mock().setData("RedisModule_CallReplyType_null", 1);
 377
 378     mock().expectOneCall("RedisModule_CloseKey");
 379     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_IE);
 380     CHECK_EQUAL(ret, 0);
 381     mock().checkExpectations();
 382     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 383     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
 384     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
 385     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 386     delete []redisStrVec;
 387 }
 388
 389
 390 TEST(exstring, delne_command_key_string_same_reply)
 391 {
 392     RedisModuleCtx ctx;
 393     //RedisModuleString str;
 394     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 395
 396     redisStrVec[0] = (RedisModuleString *)1;
 397     redisStrVec[1] = (RedisModuleString *)1;
 398     redisStrVec[2] = (RedisModuleString *)1;
 399
 400     mock().setData("RedisModule_OpenKey_have", 1);
 401     mock().setData("RedisModule_KeyType_str", 1);
 402     mock().setData("RedisModule_String_same", 1);
 403     mock().setData("RedisModule_CallReplyType_inter", 1);
 404
 405     mock().expectOneCall("RedisModule_CloseKey");
 406     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_NE);
 407     CHECK_EQUAL(ret, 0);
 408     mock().checkExpectations();
 409     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 410     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
 411     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
 412     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
 413     delete []redisStrVec;
 414
 415 }
 416
 417 TEST(exstring, delne_command_key_string_nosame_reply)
 418 {
 419     RedisModuleCtx ctx;
 420     //RedisModuleString str;
 421     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 422
 423     redisStrVec[0] = (RedisModuleString *)1;
 424     redisStrVec[1] = (RedisModuleString *)1;
 425     redisStrVec[2] = (RedisModuleString *)1;
 426
 427     mock().setData("RedisModule_OpenKey_have", 1);
 428     mock().setData("RedisModule_KeyType_str", 1);
 429     mock().setData("RedisModule_String_nosame", 1);
 430     mock().setData("RedisModule_CallReplyType_inter", 1);
 431
 432     mock().expectOneCall("RedisModule_CloseKey");
 433     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_NE);
 434     CHECK_EQUAL(ret, 0);
 435     mock().checkExpectations();
 436     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 437     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
 438     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
 439     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 440     delete []redisStrVec;
 441
 442 }
 443
 444 TEST(exstring, setpub)
 445 {
 446     RedisModuleCtx ctx;
 447     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 448
 449     redisStrVec[0] = (RedisModuleString *)1;
 450     redisStrVec[1] = (RedisModuleString *)1;
 451     redisStrVec[2] = (RedisModuleString *)1;
 452     redisStrVec[3] = (RedisModuleString *)1;
 453     redisStrVec[4] = (RedisModuleString *)1;
 454
 455     mock().setData("RedisModule_OpenKey_have", 1);
 456     mock().setData("RedisModule_KeyType_str", 1);
 457     mock().setData("RedisModule_String_same", 1);
 458     mock().setData("RedisModule_CallReplyType_null", 1);
 459
 460     int ret = SetPub_RedisCommand(&ctx, redisStrVec,  5);
 461     CHECK_EQUAL(ret, REDISMODULE_OK);
 462     mock().checkExpectations();
 463     delete []redisStrVec;
 464 }
 465
 466 TEST(exstring, setmpub)
 467 {
 468     RedisModuleCtx ctx;
 469     RedisModuleString ** redisStrVec = new (RedisModuleString*[11]);
 470
 471     for (int i = 0 ; i < 11 ; ++i)
 472         redisStrVec[i] = (RedisModuleString *)1;
 473
 474     mock().setData("RedisModule_OpenKey_have", 1);
 475     mock().setData("RedisModule_KeyType_str", 1);
 476     mock().setData("RedisModule_String_same", 1);
 477     mock().setData("RedisModule_CallReplyType_null", 1);
 478     mock().setData("RedisModule_StringToLongLongCallCount", 0);
 479     mock().setData("RedisModule_StringToLongLongCall_1", 2);
 480     mock().setData("RedisModule_StringToLongLongCall_2", 2);
 481
 482     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 11);
 483     CHECK_EQUAL(ret, REDISMODULE_OK);
 484     mock().checkExpectations();
 485     delete []redisStrVec;
 486 }
 487
 488 TEST(exstring, setxxpub)
 489 {
 490     RedisModuleCtx ctx;
 491     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 492
 493     redisStrVec[0] = (RedisModuleString *)1;
 494     redisStrVec[1] = (RedisModuleString *)1;
 495     redisStrVec[2] = (RedisModuleString *)1;
 496     redisStrVec[3] = (RedisModuleString *)1;
 497     redisStrVec[4] = (RedisModuleString *)1;
 498
 499     mock().setData("RedisModule_OpenKey_have", 1);
 500     mock().setData("RedisModule_KeyType_str", 1);
 501     mock().setData("RedisModule_String_same", 1);
 502     mock().setData("RedisModule_CallReplyType_null", 1);
 503
 504     mock().expectOneCall("RedisModule_CloseKey");
 505     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec,  5);
 506     CHECK_EQUAL(ret, REDISMODULE_OK);
 507     mock().checkExpectations();
 508     delete []redisStrVec;
 509 }
 510
 511 TEST(exstring, setnxpub)
 512 {
 513     RedisModuleCtx ctx;
 514     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 515
 516     redisStrVec[0] = (RedisModuleString *)1;
 517     redisStrVec[1] = (RedisModuleString *)1;
 518     redisStrVec[2] = (RedisModuleString *)1;
 519     redisStrVec[3] = (RedisModuleString *)1;
 520     redisStrVec[4] = (RedisModuleString *)1;
 521
 522     mock().setData("RedisModule_OpenKey_have", 1);
 523     mock().setData("RedisModule_KeyType_str", 1);
 524     mock().setData("RedisModule_String_same", 1);
 525     mock().setData("RedisModule_CallReplyType_null", 1);
 526
 527     mock().expectOneCall("RedisModule_CloseKey");
 528     int ret = SetNXPub_RedisCommand(&ctx, redisStrVec,  5);
 529     CHECK_EQUAL(ret, REDISMODULE_OK);
 530     mock().checkExpectations();
 531     delete []redisStrVec;
 532 }
 533
 534 TEST(exstring, setiepub)
 535 {
 536     RedisModuleCtx ctx;
 537     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 538
 539     redisStrVec[0] = (RedisModuleString *)1;
 540     redisStrVec[1] = (RedisModuleString *)1;
 541     redisStrVec[2] = (RedisModuleString *)1;
 542     redisStrVec[3] = (RedisModuleString *)1;
 543     redisStrVec[4] = (RedisModuleString *)1;
 544     redisStrVec[5] = (RedisModuleString *)1;
 545
 546     mock().setData("RedisModule_OpenKey_have", 1);
 547     mock().setData("RedisModule_KeyType_str", 1);
 548     mock().setData("RedisModule_String_same", 1);
 549     mock().setData("RedisModule_CallReplyType_null", 1);
 550
 551     mock().expectOneCall("RedisModule_CloseKey");
 552     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec,  6);
 553     CHECK_EQUAL(ret, REDISMODULE_OK);
 554     mock().checkExpectations();
 555     delete []redisStrVec;
 556 }
 557
 558 TEST(exstring, setnepub)
 559 {
 560     RedisModuleCtx ctx;
 561     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 562
 563     redisStrVec[0] = (RedisModuleString *)1;
 564     redisStrVec[1] = (RedisModuleString *)1;
 565     redisStrVec[2] = (RedisModuleString *)1;
 566     redisStrVec[3] = (RedisModuleString *)1;
 567     redisStrVec[4] = (RedisModuleString *)1;
 568     redisStrVec[5] = (RedisModuleString *)1;
 569
 570     mock().setData("RedisModule_OpenKey_have", 1);
 571     mock().setData("RedisModule_KeyType_str", 1);
 572     mock().setData("RedisModule_String_same", 1);
 573     mock().setData("RedisModule_CallReplyType_null", 1);
 574
 575     mock().expectOneCall("RedisModule_CloseKey");
 576     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec,  6);
 577     CHECK_EQUAL(ret, REDISMODULE_OK);
 578     mock().checkExpectations();
 579     delete []redisStrVec;
 580 }
 581
 582 TEST(exstring, setpub_command_parameter_number_incorrect)
 583 {
 584     RedisModuleCtx ctx;
 585     int ret = 0;
 586
 587     ret = SetPub_RedisCommand(&ctx, 0, 2);
 588     CHECK_EQUAL(ret, REDISMODULE_ERR);
 589
 590     ret = 0;
 591     ret = SetPub_RedisCommand(&ctx, 0, 8);
 592     CHECK_EQUAL(ret, REDISMODULE_ERR);
 593
 594     ret = 0;
 595     ret = SetMPub_RedisCommand(&ctx, 0, 2);
 596     CHECK_EQUAL(ret, REDISMODULE_ERR);
 597
 598     ret = 0;
 599     ret = SetMPub_RedisCommand(&ctx, 0, 8);
 600     CHECK_EQUAL(ret, REDISMODULE_ERR);
 601
 602     ret = 0;
 603     ret = SetXXPub_RedisCommand(&ctx, 0, 3);
 604     CHECK_EQUAL(ret, REDISMODULE_ERR);
 605
 606     ret = 0;
 607     ret = SetXXPub_RedisCommand(&ctx, 0, 6);
 608     CHECK_EQUAL(ret, REDISMODULE_ERR);
 609
 610     ret = 0;
 611     ret = SetNXPub_RedisCommand(&ctx, 0, 3);
 612     CHECK_EQUAL(ret, REDISMODULE_ERR);
 613
 614     ret = 0;
 615     ret = SetNXPub_RedisCommand(&ctx, 0, 6);
 616     CHECK_EQUAL(ret, REDISMODULE_ERR);
 617
 618     ret = 0;
 619     ret = SetIEPub_RedisCommand(&ctx, 0, 4);
 620     CHECK_EQUAL(ret, REDISMODULE_ERR);
 621
 622     ret = 0;
 623     ret = SetIEPub_RedisCommand(&ctx, 0, 9);
 624     CHECK_EQUAL(ret, REDISMODULE_ERR);
 625
 626     ret = 0;
 627     ret = SetNEPub_RedisCommand(&ctx, 0, 4);
 628     CHECK_EQUAL(ret, REDISMODULE_ERR);
 629
 630     ret = 0;
 631     ret = SetNEPub_RedisCommand(&ctx, 0, 9);
 632     CHECK_EQUAL(ret, REDISMODULE_ERR);
 633 }
 634
 635 TEST(exstring, setpub_command_no_key_replynull)
 636 {
 637     RedisModuleCtx ctx;
 638     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 639
 640     redisStrVec[0] = (RedisModuleString *)0;
 641     redisStrVec[1] = (RedisModuleString *)1;
 642     redisStrVec[2] = (RedisModuleString *)2;
 643     redisStrVec[3] = (RedisModuleString *)3;
 644     redisStrVec[4] = (RedisModuleString *)4;
 645
 646     mock().setData("RedisModule_KeyType_empty", 1);
 647     mock().setData("RedisModule_CallReplyType_null", 1);
 648
 649     int ret = SetPub_RedisCommand(&ctx, redisStrVec, 5);
 650     CHECK_EQUAL(ret, REDISMODULE_OK);
 651     mock().checkExpectations();
 652     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 653     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 654     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 655     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
 656
 657     delete []redisStrVec;
 658
 659 }
 660
 661 TEST(exstring, setpub_command_no_key_replystr)
 662 {
 663     RedisModuleCtx ctx;
 664     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 665
 666     redisStrVec[0] = (RedisModuleString *)0;
 667     redisStrVec[1] = (RedisModuleString *)1;
 668     redisStrVec[2] = (RedisModuleString *)2;
 669     redisStrVec[3] = (RedisModuleString *)3;
 670     redisStrVec[4] = (RedisModuleString *)4;
 671
 672     mock().setData("RedisModule_KeyType_empty", 1);
 673     mock().setData("RedisModule_CallReplyType_str", 1);
 674
 675     int ret = SetPub_RedisCommand(&ctx, redisStrVec, 5);
 676     CHECK_EQUAL(ret, REDISMODULE_OK);
 677     mock().checkExpectations();
 678     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 679     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 680     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 681     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 682
 683     delete []redisStrVec;
 684
 685 }
 686
 687 TEST(exstring, setmpub_command_no_key_replynull)
 688 {
 689     RedisModuleCtx ctx;
 690     RedisModuleString ** redisStrVec = new (RedisModuleString*[9]);
 691
 692     redisStrVec[0] = (RedisModuleString *)0;
 693     redisStrVec[1] = (RedisModuleString *)1;
 694     redisStrVec[2] = (RedisModuleString *)2;
 695     redisStrVec[3] = (RedisModuleString *)3;
 696     redisStrVec[4] = (RedisModuleString *)4;
 697     redisStrVec[5] = (RedisModuleString *)5;
 698     redisStrVec[6] = (RedisModuleString *)6;
 699     redisStrVec[7] = (RedisModuleString *)7;
 700     redisStrVec[8] = (RedisModuleString *)8;
 701
 702     mock().setData("RedisModule_KeyType_empty", 1);
 703     mock().setData("RedisModule_CallReplyType_null", 1);
 704     mock().setData("RedisModule_StringToLongLongCall_1", 1);
 705     mock().setData("RedisModule_StringToLongLongCall_2", 2);
 706
 707     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 9);
 708     CHECK_EQUAL(ret, REDISMODULE_OK);
 709     mock().checkExpectations();
 710     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 711     CHECK_EQUAL(1, mock().getData("MSET").getIntValue());
 712     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
 713     CHECK_EQUAL(1, mock().getData("RedisModule_FreeCallReply").getIntValue());
 714
 715     delete []redisStrVec;
 716
 717 }
 718
 719 TEST(exstring, setmpub_command_negative_key_val_count)
 720 {
 721     RedisModuleCtx ctx;
 722     RedisModuleString ** redisStrVec = new (RedisModuleString*[7]);
 723
 724     redisStrVec[0] = (RedisModuleString *)0;
 725     redisStrVec[1] = (RedisModuleString *)1;
 726     redisStrVec[2] = (RedisModuleString *)2;
 727     redisStrVec[3] = (RedisModuleString *)3;
 728     redisStrVec[4] = (RedisModuleString *)4;
 729     redisStrVec[5] = (RedisModuleString *)5;
 730     redisStrVec[6] = (RedisModuleString *)6;
 731
 732     mock().setData("RedisModule_KeyType_empty", 1);
 733     mock().setData("RedisModule_CallReplyType_str", 1);
 734     mock().setData("RedisModule_StringToLongLongCall_1", -1);
 735     mock().setData("RedisModule_StringToLongLongCall_2", 1);
 736
 737     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 7);
 738     CHECK_EQUAL(ret, REDISMODULE_OK);
 739     mock().checkExpectations();
 740     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 741     CHECK_EQUAL(0, mock().getData("MSET").getIntValue());
 742     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
 743     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
 744     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
 745
 746     delete []redisStrVec;
 747
 748 }
 749
 750 TEST(exstring, setmpub_command_negative_chan_msg_count)
 751 {
 752     RedisModuleCtx ctx;
 753     RedisModuleString ** redisStrVec = new (RedisModuleString*[7]);
 754
 755     redisStrVec[0] = (RedisModuleString *)0;
 756     redisStrVec[1] = (RedisModuleString *)1;
 757     redisStrVec[2] = (RedisModuleString *)2;
 758     redisStrVec[3] = (RedisModuleString *)3;
 759     redisStrVec[4] = (RedisModuleString *)4;
 760     redisStrVec[5] = (RedisModuleString *)5;
 761     redisStrVec[6] = (RedisModuleString *)6;
 762
 763     mock().setData("RedisModule_KeyType_empty", 1);
 764     mock().setData("RedisModule_CallReplyType_str", 1);
 765     mock().setData("RedisModule_StringToLongLongCall_1", 1);
 766     mock().setData("RedisModule_StringToLongLongCall_2", -1);
 767
 768     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 7);
 769     CHECK_EQUAL(ret, REDISMODULE_OK);
 770     mock().checkExpectations();
 771     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 772     CHECK_EQUAL(0, mock().getData("MSET").getIntValue());
 773     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
 774     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
 775     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
 776
 777     delete []redisStrVec;
 778
 779 }
 780
 781 TEST(exstring, setmpub_command_invalid_total_count)
 782 {
 783     RedisModuleCtx ctx;
 784     RedisModuleString ** redisStrVec = new (RedisModuleString*[7]);
 785
 786     redisStrVec[0] = (RedisModuleString *)0;
 787     redisStrVec[1] = (RedisModuleString *)1;
 788     redisStrVec[2] = (RedisModuleString *)2;
 789     redisStrVec[3] = (RedisModuleString *)3;
 790     redisStrVec[4] = (RedisModuleString *)4;
 791     redisStrVec[5] = (RedisModuleString *)5;
 792     redisStrVec[6] = (RedisModuleString *)6;
 793
 794     mock().setData("RedisModule_KeyType_empty", 1);
 795     mock().setData("RedisModule_CallReplyType_str", 1);
 796     mock().setData("RedisModule_StringToLongLongCall_1", 100);
 797     mock().setData("RedisModule_StringToLongLongCall_2", 100);
 798
 799     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 7);
 800     CHECK_EQUAL(ret, REDISMODULE_OK);
 801     mock().checkExpectations();
 802     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 803     CHECK_EQUAL(0, mock().getData("MSET").getIntValue());
 804     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
 805     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
 806     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
 807
 808     delete []redisStrVec;
 809
 810 }
 811
 812 TEST(exstring, setmpub_command_set)
 813 {
 814     RedisModuleCtx ctx;
 815     RedisModuleString ** redisStrVec = new (RedisModuleString*[7]);
 816
 817     redisStrVec[0] = (RedisModuleString *)0;
 818     redisStrVec[1] = (RedisModuleString *)1;
 819     redisStrVec[2] = (RedisModuleString *)2;
 820     redisStrVec[3] = (RedisModuleString *)3;
 821     redisStrVec[4] = (RedisModuleString *)4;
 822     redisStrVec[5] = (RedisModuleString *)5;
 823     redisStrVec[6] = (RedisModuleString *)6;
 824
 825     mock().setData("RedisModule_KeyType_empty", 1);
 826     mock().setData("RedisModule_CallReplyType_str", 1);
 827     mock().setData("RedisModule_StringToLongLongCall_1", 1);
 828     mock().setData("RedisModule_StringToLongLongCall_2", 1);
 829
 830     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 7);
 831     CHECK_EQUAL(ret, REDISMODULE_OK);
 832     mock().checkExpectations();
 833     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 834     CHECK_EQUAL(1, mock().getData("MSET").getIntValue());
 835     CHECK_EQUAL(1, mock().getData("PUBLISH").getIntValue());
 836     CHECK_EQUAL(2, mock().getData("RedisModule_FreeCallReply").getIntValue());
 837
 838     delete []redisStrVec;
 839
 840 }
 841
 842 TEST(exstring, setmpub_command_set_multipub)
 843 {
 844     RedisModuleCtx ctx;
 845     RedisModuleString ** redisStrVec = new (RedisModuleString*[9]);
 846
 847     redisStrVec[0] = (RedisModuleString *)0;
 848     redisStrVec[1] = (RedisModuleString *)1;
 849     redisStrVec[2] = (RedisModuleString *)2;
 850     redisStrVec[3] = (RedisModuleString *)3;
 851     redisStrVec[4] = (RedisModuleString *)4;
 852     redisStrVec[5] = (RedisModuleString *)5;
 853     redisStrVec[6] = (RedisModuleString *)6;
 854     redisStrVec[7] = (RedisModuleString *)7;
 855     redisStrVec[8] = (RedisModuleString *)8;
 856
 857     mock().setData("RedisModule_KeyType_empty", 1);
 858     mock().setData("RedisModule_CallReplyType_str", 1);
 859     mock().setData("RedisModule_StringToLongLongCall_1", 1);
 860     mock().setData("RedisModule_StringToLongLongCall_2", 2);
 861
 862     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 9);
 863     CHECK_EQUAL(ret, REDISMODULE_OK);
 864     mock().checkExpectations();
 865     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 866     CHECK_EQUAL(1, mock().getData("MSET").getIntValue());
 867     CHECK_EQUAL(2, mock().getData("PUBLISH").getIntValue());
 868     CHECK_EQUAL(3, mock().getData("RedisModule_FreeCallReply").getIntValue());
 869
 870     delete []redisStrVec;
 871
 872 }
 873
 874 TEST(exstring, setxxpub_command_has_no_key)
 875 {
 876     RedisModuleCtx ctx;
 877     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 878
 879     redisStrVec[0] = (RedisModuleString *)0;
 880     redisStrVec[1] = (RedisModuleString *)1;
 881     redisStrVec[2] = (RedisModuleString *)2;
 882     redisStrVec[3] = (RedisModuleString *)3;
 883     redisStrVec[4] = (RedisModuleString *)4;
 884
 885     mock().setData("RedisModule_KeyType_empty", 1);
 886     mock().setData("RedisModule_CallReplyType_null", 1);
 887
 888     mock().expectOneCall("RedisModule_CloseKey");
 889     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec, 5);
 890
 891     CHECK_EQUAL(ret, REDISMODULE_OK);
 892     mock().checkExpectations();
 893     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 894     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 895     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 896     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 897     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 898
 899     delete []redisStrVec;
 900
 901 }
 902
 903 TEST(exstring, setxxpub_command_parameter_has_key_set)
 904 {
 905     RedisModuleCtx ctx;
 906     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 907
 908     redisStrVec[0] = (RedisModuleString *)0;
 909     redisStrVec[1] = (RedisModuleString *)1;
 910     redisStrVec[2] = (RedisModuleString *)2;
 911     redisStrVec[3] = (RedisModuleString *)3;
 912     redisStrVec[4] = (RedisModuleString *)4;
 913
 914     mock().setData("RedisModule_KeyType_set", 1);
 915
 916     mock().expectOneCall("RedisModule_CloseKey");
 917     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec, 5);
 918
 919     CHECK_EQUAL(ret, REDISMODULE_OK);
 920     mock().checkExpectations();
 921     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
 922     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 923     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 924     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 925     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 926
 927     delete []redisStrVec;
 928
 929 }
 930
 931 TEST(exstring, setxxpub_command_has_key_string)
 932 {
 933     RedisModuleCtx ctx;
 934     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 935
 936     redisStrVec[0] = (RedisModuleString *)0;
 937     redisStrVec[1] = (RedisModuleString *)1;
 938     redisStrVec[2] = (RedisModuleString *)2;
 939     redisStrVec[3] = (RedisModuleString *)3;
 940     redisStrVec[4] = (RedisModuleString *)4;
 941
 942     mock().setData("RedisModule_KeyType_str", 1);
 943     mock().setData("RedisModule_CallReplyType_str", 1);
 944
 945     mock().expectOneCall("RedisModule_CloseKey");
 946     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec, 5);
 947
 948     CHECK_EQUAL(ret, REDISMODULE_OK);
 949     mock().checkExpectations();
 950     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
 951     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 952     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 953     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 954     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 955
 956     delete []redisStrVec;
 957
 958 }
 959
 960
 961 TEST(exstring, setnxpub_command_has_key_string)
 962 {
 963     RedisModuleCtx ctx;
 964     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 965
 966     redisStrVec[0] = (RedisModuleString *)0;
 967     redisStrVec[1] = (RedisModuleString *)1;
 968     redisStrVec[2] = (RedisModuleString *)2;
 969     redisStrVec[3] = (RedisModuleString *)3;
 970     redisStrVec[4] = (RedisModuleString *)4;
 971
 972     mock().setData("RedisModule_KeyType_str", 1);
 973     mock().setData("RedisModule_CallReplyType_null", 1);
 974
 975     mock().expectOneCall("RedisModule_CloseKey");
 976     int ret = SetNXPub_RedisCommand(&ctx, redisStrVec, 5);
 977
 978     CHECK_EQUAL(ret, REDISMODULE_OK);
 979     mock().checkExpectations();
 980     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 981     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 982     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 983     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 984     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 985
 986     delete []redisStrVec;
 987
 988 }
 989
 990 TEST(exstring, setnxpub_command_has_no_key)
 991 {
 992     RedisModuleCtx ctx;
 993     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 994
 995     redisStrVec[0] = (RedisModuleString *)0;
 996     redisStrVec[1] = (RedisModuleString *)1;
 997     redisStrVec[2] = (RedisModuleString *)2;
 998     redisStrVec[3] = (RedisModuleString *)3;
 999     redisStrVec[4] = (RedisModuleString *)4;
1000
1001     mock().setData("RedisModule_KeyType_empty", 1);
1002     mock().setData("RedisModule_CallReplyType_str", 1);
1003
1004     mock().expectOneCall("RedisModule_CloseKey");
1005     int ret = SetNXPub_RedisCommand(&ctx, redisStrVec, 5);
1006
1007     CHECK_EQUAL(ret, REDISMODULE_OK);
1008     mock().checkExpectations();
1009     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1010     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1011     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
1012     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1013     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
1014
1015     delete []redisStrVec;
1016
1017 }
1018
1019
1020
1021 TEST(exstring, setiepub_command_has_no_key)
1022 {
1023     RedisModuleCtx ctx;
1024     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
1025
1026     redisStrVec[0] = (RedisModuleString *)0;
1027     redisStrVec[1] = (RedisModuleString *)1;
1028     redisStrVec[2] = (RedisModuleString *)2;
1029     redisStrVec[3] = (RedisModuleString *)3;
1030     redisStrVec[4] = (RedisModuleString *)4;
1031     redisStrVec[5] = (RedisModuleString *)5;
1032
1033     mock().setData("RedisModule_KeyType_empty", 1);
1034     mock().setData("RedisModule_CallReplyType_str", 1);
1035
1036     mock().expectOneCall("RedisModule_CloseKey");
1037     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
1038
1039     CHECK_EQUAL(ret, REDISMODULE_OK);
1040     mock().checkExpectations();
1041     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
1042     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1043     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
1044     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1045     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1046
1047     delete []redisStrVec;
1048
1049 }
1050
1051
1052 TEST(exstring, setiepub_command_key_string_nosame)
1053 {
1054     RedisModuleCtx ctx;
1055     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
1056
1057     redisStrVec[0] = (RedisModuleString *)0;
1058     redisStrVec[1] = (RedisModuleString *)1;
1059     redisStrVec[2] = (RedisModuleString *)2;
1060     redisStrVec[3] = (RedisModuleString *)3;
1061     redisStrVec[4] = (RedisModuleString *)4;
1062     redisStrVec[5] = (RedisModuleString *)5;
1063
1064     mock().setData("RedisModule_KeyType_str", 1);
1065     mock().setData("RedisModule_CallReplyType_str", 1);
1066     mock().setData("RedisModule_String_nosame", 1);
1067
1068     mock().expectOneCall("RedisModule_CloseKey");
1069     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
1070
1071     CHECK_EQUAL(ret, REDISMODULE_OK);
1072     mock().checkExpectations();
1073     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
1074     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1075     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
1076     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1077     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1078
1079     delete []redisStrVec;
1080
1081 }
1082
1083 TEST(exstring, setiepub_command_key_same_string_replynull)
1084 {
1085     RedisModuleCtx ctx;
1086     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
1087
1088     redisStrVec[0] = (RedisModuleString *)0;
1089     redisStrVec[1] = (RedisModuleString *)1;
1090     redisStrVec[2] = (RedisModuleString *)2;
1091     redisStrVec[3] = (RedisModuleString *)3;
1092     redisStrVec[4] = (RedisModuleString *)4;
1093     redisStrVec[5] = (RedisModuleString *)5;
1094
1095     mock().setData("RedisModule_KeyType_str", 1);
1096     mock().setData("RedisModule_String_same", 1);
1097     mock().setData("RedisModule_CallReplyType_null", 1);
1098
1099     mock().expectOneCall("RedisModule_CloseKey");
1100     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
1101
1102     CHECK_EQUAL(ret, REDISMODULE_OK);
1103     mock().checkExpectations();
1104     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1105     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
1106     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
1107     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1108     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
1109
1110     delete []redisStrVec;
1111
1112 }
1113
1114 TEST(exstring, setiepub_command_key_same_string_reply)
1115 {
1116     RedisModuleCtx ctx;
1117     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
1118
1119     redisStrVec[0] = (RedisModuleString *)0;
1120     redisStrVec[1] = (RedisModuleString *)1;
1121     redisStrVec[2] = (RedisModuleString *)2;
1122     redisStrVec[3] = (RedisModuleString *)3;
1123     redisStrVec[4] = (RedisModuleString *)4;
1124     redisStrVec[5] = (RedisModuleString *)5;
1125
1126     mock().setData("RedisModule_KeyType_str", 1);
1127     mock().setData("RedisModule_String_same", 1);
1128     mock().setData("RedisModule_CallReplyType_str", 1);
1129
1130     mock().expectOneCall("RedisModule_CloseKey");
1131     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
1132
1133     CHECK_EQUAL(ret, REDISMODULE_OK);
1134     mock().checkExpectations();
1135     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1136     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
1137     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1138     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1139     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1140
1141     delete []redisStrVec;
1142
1143 }
1144
1145 TEST(exstring, setnepub_command_has_no_key)
1146 {
1147     RedisModuleCtx ctx;
1148     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
1149
1150     redisStrVec[0] = (RedisModuleString *)0;
1151     redisStrVec[1] = (RedisModuleString *)1;
1152     redisStrVec[2] = (RedisModuleString *)2;
1153     redisStrVec[3] = (RedisModuleString *)3;
1154     redisStrVec[4] = (RedisModuleString *)4;
1155     redisStrVec[5] = (RedisModuleString *)5;
1156
1157     mock().setData("RedisModule_KeyType_empty", 1);
1158     mock().setData("RedisModule_CallReplyType_str", 1);
1159     mock().setData("RedisModule_String_nosame", 1);
1160
1161     mock().expectOneCall("RedisModule_CloseKey");
1162     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec, 6);
1163
1164     CHECK_EQUAL(ret, REDISMODULE_OK);
1165     mock().checkExpectations();
1166     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1167     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
1168     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1169     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1170     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1171
1172     delete []redisStrVec;
1173
1174 }
1175
1176 TEST(exstring, setnepub_command_key_string_same_reply)
1177 {
1178     RedisModuleCtx ctx;
1179     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
1180
1181     redisStrVec[0] = (RedisModuleString *)0;
1182     redisStrVec[1] = (RedisModuleString *)1;
1183     redisStrVec[2] = (RedisModuleString *)2;
1184     redisStrVec[3] = (RedisModuleString *)3;
1185     redisStrVec[4] = (RedisModuleString *)4;
1186     redisStrVec[5] = (RedisModuleString *)5;
1187
1188     mock().setData("RedisModule_KeyType_str", 1);
1189     mock().setData("RedisModule_String_same", 1);
1190     mock().setData("RedisModule_CallReplyType_str", 1);
1191
1192     mock().expectOneCall("RedisModule_CloseKey");
1193     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec, 6);
1194
1195     CHECK_EQUAL(ret, REDISMODULE_OK);
1196     mock().checkExpectations();
1197     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1198     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
1199     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
1200     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1201     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1202
1203     delete []redisStrVec;
1204
1205 }
1206
1207
1208 TEST(exstring, setnepub_command_key_string_nosame_reply)
1209 {
1210     RedisModuleCtx ctx;
1211     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
1212
1213     redisStrVec[0] = (RedisModuleString *)0;
1214     redisStrVec[1] = (RedisModuleString *)1;
1215     redisStrVec[2] = (RedisModuleString *)2;
1216     redisStrVec[3] = (RedisModuleString *)3;
1217     redisStrVec[4] = (RedisModuleString *)4;
1218     redisStrVec[5] = (RedisModuleString *)5;
1219
1220     mock().setData("RedisModule_KeyType_str", 1);
1221     mock().setData("RedisModule_CallReplyType_str", 1);
1222     mock().setData("RedisModule_String_nosame", 1);
1223
1224     mock().expectOneCall("RedisModule_CloseKey");
1225     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec, 6);
1226
1227     CHECK_EQUAL(ret, REDISMODULE_OK);
1228     mock().checkExpectations();
1229     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1230     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
1231     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1232     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1233     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1234
1235     delete []redisStrVec;
1236
1237 }
1238
1239 TEST(exstring, delpub)
1240 {
1241     RedisModuleCtx ctx;
1242     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
1243
1244     redisStrVec[0] = (RedisModuleString *)1;
1245     redisStrVec[1] = (RedisModuleString *)1;
1246     redisStrVec[2] = (RedisModuleString *)1;
1247     redisStrVec[3] = (RedisModuleString *)1;
1248
1249     mock().setData("RedisModule_OpenKey_have", 1);
1250     mock().setData("RedisModule_KeyType_str", 1);
1251     mock().setData("RedisModule_String_same", 1);
1252     mock().setData("RedisModule_CallReplyType_null", 1);
1253
1254     int ret = DelPub_RedisCommand(&ctx, redisStrVec,  4);
1255     CHECK_EQUAL(ret, REDISMODULE_OK);
1256
1257     delete []redisStrVec;
1258 }
1259
1260 TEST(exstring, delmpub)
1261 {
1262     RedisModuleCtx ctx;
1263     RedisModuleString ** redisStrVec = new (RedisModuleString*[8]);
1264
1265     redisStrVec[0] = (RedisModuleString *)1;
1266     redisStrVec[1] = (RedisModuleString *)1;
1267     redisStrVec[2] = (RedisModuleString *)1;
1268     redisStrVec[3] = (RedisModuleString *)1;
1269     redisStrVec[4] = (RedisModuleString *)1;
1270     redisStrVec[5] = (RedisModuleString *)1;
1271     redisStrVec[6] = (RedisModuleString *)1;
1272     redisStrVec[7] = (RedisModuleString *)1;
1273
1274     mock().setData("RedisModule_OpenKey_have", 1);
1275     mock().setData("RedisModule_KeyType_str", 1);
1276     mock().setData("RedisModule_String_same", 1);
1277     mock().setData("RedisModule_CallReplyType_null", 1);
1278     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1279     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1280     mock().setData("RedisModule_StringToLongLongCall_2", 2);
1281
1282     int ret = DelMPub_RedisCommand(&ctx, redisStrVec,  8);
1283     CHECK_EQUAL(ret, REDISMODULE_OK);
1284
1285     delete []redisStrVec;
1286 }
1287
1288 TEST(exstring, deliepub)
1289 {
1290     RedisModuleCtx ctx;
1291     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1292
1293     redisStrVec[0] = (RedisModuleString *)1;
1294     redisStrVec[1] = (RedisModuleString *)1;
1295     redisStrVec[2] = (RedisModuleString *)1;
1296     redisStrVec[3] = (RedisModuleString *)1;
1297     redisStrVec[4] = (RedisModuleString *)1;
1298
1299     mock().setData("RedisModule_OpenKey_have", 1);
1300     mock().setData("RedisModule_KeyType_str", 1);
1301     mock().setData("RedisModule_String_same", 1);
1302     mock().setData("RedisModule_CallReplyType_null", 1);
1303
1304     mock().expectOneCall("RedisModule_CloseKey");
1305     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec,  5);
1306     CHECK_EQUAL(ret, REDISMODULE_OK);
1307     mock().checkExpectations();
1308     delete []redisStrVec;
1309 }
1310
1311 TEST(exstring, delnepub)
1312 {
1313     RedisModuleCtx ctx;
1314     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1315
1316     redisStrVec[0] = (RedisModuleString *)1;
1317     redisStrVec[1] = (RedisModuleString *)1;
1318     redisStrVec[2] = (RedisModuleString *)1;
1319     redisStrVec[3] = (RedisModuleString *)1;
1320     redisStrVec[4] = (RedisModuleString *)1;
1321
1322     mock().setData("RedisModule_OpenKey_have", 1);
1323     mock().setData("RedisModule_KeyType_str", 1);
1324     mock().setData("RedisModule_String_same", 1);
1325     mock().setData("RedisModule_CallReplyType_null", 1);
1326
1327     mock().expectOneCall("RedisModule_CloseKey");
1328     int ret = DelNEPub_RedisCommand(&ctx, redisStrVec,  5);
1329     CHECK_EQUAL(ret, REDISMODULE_OK);
1330     mock().checkExpectations();
1331     delete []redisStrVec;
1332 }
1333
1334 TEST(exstring, delpub_command_parameter_number_incorrect)
1335 {
1336     RedisModuleCtx ctx;
1337     int ret = 0;
1338     ret = DelPub_RedisCommand(&ctx, 0, 2);
1339     CHECK_EQUAL(ret, REDISMODULE_ERR);
1340
1341     ret = 0;
1342     ret = DelMPub_RedisCommand(&ctx, 0, 5);
1343     CHECK_EQUAL(ret, REDISMODULE_ERR);
1344
1345     ret = 0;
1346     ret = DelIEPub_RedisCommand(&ctx, 0, 4);
1347     CHECK_EQUAL(ret, REDISMODULE_ERR);
1348
1349     ret = 0;
1350     ret = DelNEPub_RedisCommand(&ctx, 0, 8);
1351     CHECK_EQUAL(ret, REDISMODULE_ERR);
1352 }
1353
1354 TEST(exstring, delpub_command_reply_null)
1355 {
1356     RedisModuleCtx ctx;
1357     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1358
1359     redisStrVec[0] = (RedisModuleString *)1;
1360     redisStrVec[1] = (RedisModuleString *)1;
1361     redisStrVec[2] = (RedisModuleString *)1;
1362     redisStrVec[3] = (RedisModuleString *)1;
1363     redisStrVec[4] = (RedisModuleString *)1;
1364     mock().setData("RedisModule_CallReplyInteger", 0);
1365     mock().setData("RedisModule_CallReplyType_inter", 1);
1366     mock().setData("RedisModule_Call_Return_Null", 0);
1367
1368     int ret = DelPub_RedisCommand(&ctx, redisStrVec, 5);
1369     CHECK_EQUAL(ret, 0);
1370     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1371     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1372     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1373     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 0);
1374     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1375     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
1376     delete []redisStrVec;
1377
1378 }
1379
1380 TEST(exstring, delpub_command_reply_error)
1381 {
1382     RedisModuleCtx ctx;
1383     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1384
1385     redisStrVec[0] = (RedisModuleString *)1;
1386     redisStrVec[1] = (RedisModuleString *)1;
1387     redisStrVec[2] = (RedisModuleString *)1;
1388     redisStrVec[3] = (RedisModuleString *)1;
1389     redisStrVec[4] = (RedisModuleString *)1;
1390     mock().setData("RedisModule_CallReplyInteger", 0);
1391     mock().setData("RedisModule_CallReplyType_err", 1);
1392
1393     int ret = DelPub_RedisCommand(&ctx, redisStrVec, 5);
1394     CHECK_EQUAL(ret, REDISMODULE_ERR);
1395     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1396     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1397     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1398     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1399     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1400     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1401     delete []redisStrVec;
1402
1403 }
1404
1405 TEST(exstring, delpub_command_has_no_key)
1406 {
1407     RedisModuleCtx ctx;
1408     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1409
1410     redisStrVec[0] = (RedisModuleString *)1;
1411     redisStrVec[1] = (RedisModuleString *)1;
1412     redisStrVec[2] = (RedisModuleString *)1;
1413     redisStrVec[3] = (RedisModuleString *)1;
1414     redisStrVec[4] = (RedisModuleString *)1;
1415     mock().setData("RedisModule_CallReplyInteger", 0);
1416     mock().setData("RedisModule_CallReplyType_inter", 1);
1417
1418     int ret = DelPub_RedisCommand(&ctx, redisStrVec, 5);
1419     CHECK_EQUAL(ret, 0);
1420     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1421     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1422     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1423     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1424     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1425     delete []redisStrVec;
1426
1427 }
1428
1429 TEST(exstring, delmpub_command_reply_null)
1430 {
1431     RedisModuleCtx ctx;
1432     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1433
1434     redisStrVec[0] = (RedisModuleString *)1;
1435     redisStrVec[1] = (RedisModuleString *)1;
1436     redisStrVec[2] = (RedisModuleString *)1;
1437     redisStrVec[3] = (RedisModuleString *)1;
1438     redisStrVec[4] = (RedisModuleString *)1;
1439     redisStrVec[5] = (RedisModuleString *)1;
1440
1441     mock().setData("RedisModule_Call_Return_Null", 1);
1442     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1443     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1444     mock().setData("RedisModule_StringToLongLongCall_2", 1);
1445
1446     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1447     CHECK_EQUAL(ret, 0);
1448     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1449     CHECK_EQUAL(1, mock().getData("UNLINK").getIntValue());
1450     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
1451     CHECK_EQUAL(0, mock().getData("RedisModule_ReplyWithCallReply").getIntValue());
1452     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
1453     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
1454     delete []redisStrVec;
1455
1456 }
1457
1458 TEST(exstring, delmpub_command_reply_error)
1459 {
1460     RedisModuleCtx ctx;
1461     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1462
1463     redisStrVec[0] = (RedisModuleString *)1;
1464     redisStrVec[1] = (RedisModuleString *)1;
1465     redisStrVec[2] = (RedisModuleString *)1;
1466     redisStrVec[3] = (RedisModuleString *)1;
1467     redisStrVec[4] = (RedisModuleString *)1;
1468     redisStrVec[4] = (RedisModuleString *)1;
1469
1470     mock().setData("RedisModule_CallReplyInteger", 0);
1471     mock().setData("RedisModule_CallReplyType_err", 1);
1472     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1473     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1474     mock().setData("RedisModule_StringToLongLongCall_2", 1);
1475
1476     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1477     CHECK_EQUAL(ret, REDISMODULE_ERR);
1478     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1479     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1480     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1481     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1482     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1483     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1484     delete []redisStrVec;
1485
1486 }
1487
1488 TEST(exstring, delmpub_command_has_no_key)
1489 {
1490     RedisModuleCtx ctx;
1491     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1492
1493     redisStrVec[0] = (RedisModuleString *)1;
1494     redisStrVec[1] = (RedisModuleString *)1;
1495     redisStrVec[2] = (RedisModuleString *)1;
1496     redisStrVec[3] = (RedisModuleString *)1;
1497     redisStrVec[4] = (RedisModuleString *)1;
1498     redisStrVec[5] = (RedisModuleString *)1;
1499
1500     mock().setData("RedisModule_CallReplyInteger", 0);
1501     mock().setData("RedisModule_CallReplyType_inter", 1);
1502     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1503     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1504     mock().setData("RedisModule_StringToLongLongCall_2", 1);
1505
1506     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1507     CHECK_EQUAL(ret, 0);
1508     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1509     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1510     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1511     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1512     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1513     delete []redisStrVec;
1514
1515 }
1516
1517 TEST(exstring, delmpub_command_key_deleted)
1518 {
1519     RedisModuleCtx ctx;
1520     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1521
1522     redisStrVec[0] = (RedisModuleString *)1;
1523     redisStrVec[1] = (RedisModuleString *)1;
1524     redisStrVec[2] = (RedisModuleString *)1;
1525     redisStrVec[3] = (RedisModuleString *)1;
1526     redisStrVec[4] = (RedisModuleString *)1;
1527     redisStrVec[5] = (RedisModuleString *)1;
1528
1529     mock().setData("RedisModule_CallReplyInteger", 1);
1530     mock().setData("RedisModule_CallReplyType_inter", 1);
1531     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1532     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1533     mock().setData("RedisModule_StringToLongLongCall_2", 1);
1534
1535     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1536     CHECK_EQUAL(ret, 0);
1537     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1538     CHECK_EQUAL(1, mock().getData("UNLINK").getIntValue());
1539     CHECK_EQUAL(1, mock().getData("PUBLISH").getIntValue());
1540     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithCallReply").getIntValue());
1541     CHECK_EQUAL(2, mock().getData("RedisModule_FreeCallReply").getIntValue());
1542     delete []redisStrVec;
1543
1544 }
1545
1546 TEST(exstring, delmpub_command_key_deleted_multi_pub)
1547 {
1548     RedisModuleCtx ctx;
1549     RedisModuleString **redisStrVec = new (RedisModuleString*[10]);
1550
1551     redisStrVec[0] = (RedisModuleString *)1;
1552     redisStrVec[1] = (RedisModuleString *)1;
1553     redisStrVec[2] = (RedisModuleString *)1;
1554     redisStrVec[3] = (RedisModuleString *)1;
1555     redisStrVec[4] = (RedisModuleString *)1;
1556     redisStrVec[5] = (RedisModuleString *)1;
1557     redisStrVec[6] = (RedisModuleString *)1;
1558     redisStrVec[7] = (RedisModuleString *)1;
1559     redisStrVec[8] = (RedisModuleString *)1;
1560     redisStrVec[9] = (RedisModuleString *)1;
1561
1562     mock().setData("RedisModule_CallReplyInteger", 1);
1563     mock().setData("RedisModule_CallReplyType_inter", 1);
1564     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1565     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1566     mock().setData("RedisModule_StringToLongLongCall_2", 3);
1567
1568     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 10);
1569     CHECK_EQUAL(0, ret);
1570     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1571     CHECK_EQUAL(1, mock().getData("UNLINK").getIntValue());
1572     CHECK_EQUAL(3, mock().getData("PUBLISH").getIntValue());
1573     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithCallReply").getIntValue());
1574     CHECK_EQUAL(4, mock().getData("RedisModule_FreeCallReply").getIntValue());
1575     delete []redisStrVec;
1576
1577 }
1578
1579 TEST(exstring, delmpub_command_negative_del_count)
1580 {
1581     RedisModuleCtx ctx;
1582     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1583
1584     redisStrVec[0] = (RedisModuleString *)1;
1585     redisStrVec[1] = (RedisModuleString *)1;
1586     redisStrVec[2] = (RedisModuleString *)1;
1587     redisStrVec[3] = (RedisModuleString *)1;
1588     redisStrVec[4] = (RedisModuleString *)1;
1589     redisStrVec[5] = (RedisModuleString *)1;
1590
1591     mock().setData("RedisModule_CallReplyInteger", 1);
1592     mock().setData("RedisModule_CallReplyType_inter", 1);
1593     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1594     mock().setData("RedisModule_StringToLongLongCall_1", -1);
1595     mock().setData("RedisModule_StringToLongLongCall_2", 1);
1596
1597     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1598     CHECK_EQUAL(0, ret);
1599     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1600     CHECK_EQUAL(0, mock().getData("UNLINK").getIntValue());
1601     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
1602     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
1603     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
1604     delete []redisStrVec;
1605
1606 }
1607
1608 TEST(exstring, delmpub_command_negative_chan_msg_count)
1609 {
1610     RedisModuleCtx ctx;
1611     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1612
1613     redisStrVec[0] = (RedisModuleString *)1;
1614     redisStrVec[1] = (RedisModuleString *)1;
1615     redisStrVec[2] = (RedisModuleString *)1;
1616     redisStrVec[3] = (RedisModuleString *)1;
1617     redisStrVec[4] = (RedisModuleString *)1;
1618     redisStrVec[5] = (RedisModuleString *)1;
1619
1620     mock().setData("RedisModule_CallReplyInteger", 1);
1621     mock().setData("RedisModule_CallReplyType_inter", 1);
1622     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1623     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1624     mock().setData("RedisModule_StringToLongLongCall_2", -1);
1625
1626     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1627     CHECK_EQUAL(0, ret);
1628     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1629     CHECK_EQUAL(0, mock().getData("UNLINK").getIntValue());
1630     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
1631     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
1632     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
1633     delete []redisStrVec;
1634
1635 }
1636
1637 TEST(exstring, delmpub_command_invalid_total_count)
1638 {
1639     RedisModuleCtx ctx;
1640     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1641
1642     redisStrVec[0] = (RedisModuleString *)1;
1643     redisStrVec[1] = (RedisModuleString *)1;
1644     redisStrVec[2] = (RedisModuleString *)1;
1645     redisStrVec[3] = (RedisModuleString *)1;
1646     redisStrVec[4] = (RedisModuleString *)1;
1647     redisStrVec[5] = (RedisModuleString *)1;
1648
1649     mock().setData("RedisModule_CallReplyInteger", 1);
1650     mock().setData("RedisModule_CallReplyType_inter", 1);
1651     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1652     mock().setData("RedisModule_StringToLongLongCall_1", 100);
1653     mock().setData("RedisModule_StringToLongLongCall_2", 100);
1654
1655     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1656     CHECK_EQUAL(0, ret);
1657     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1658     CHECK_EQUAL(0, mock().getData("UNLINK").getIntValue());
1659     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
1660     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
1661     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
1662     delete []redisStrVec;
1663
1664 }
1665
1666 TEST(exstring, deliepub_command_has_no_key)
1667 {
1668     RedisModuleCtx ctx;
1669     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1670
1671     redisStrVec[0] = (RedisModuleString *)1;
1672     redisStrVec[1] = (RedisModuleString *)1;
1673     redisStrVec[2] = (RedisModuleString *)1;
1674     redisStrVec[3] = (RedisModuleString *)1;
1675     redisStrVec[4] = (RedisModuleString *)1;
1676     mock().setData("RedisModule_KeyType_empty", 1);
1677
1678     mock().expectOneCall("RedisModule_CloseKey");
1679     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec, 5);
1680     CHECK_EQUAL(ret, 0);
1681     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1682     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1683     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1684     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1685     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1686     delete []redisStrVec;
1687
1688 }
1689
1690 TEST(exstring, deliepub_command_has_key_set)
1691 {
1692     RedisModuleCtx ctx;
1693     //RedisModuleString str;
1694     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1695
1696     redisStrVec[0] = (RedisModuleString *)1;
1697     redisStrVec[1] = (RedisModuleString *)1;
1698     redisStrVec[2] = (RedisModuleString *)1;
1699     redisStrVec[3] = (RedisModuleString *)1;
1700     redisStrVec[4] = (RedisModuleString *)1;
1701
1702     mock().setData("RedisModule_OpenKey_have", 1);
1703     mock().setData("RedisModule_KeyType_set", 1);
1704     mock().expectOneCall("RedisModule_CloseKey");
1705     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec, 5);
1706     CHECK_EQUAL(ret, REDISMODULE_OK);
1707     mock().checkExpectations();
1708     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
1709     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1710     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1711     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1712     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1713
1714     delete []redisStrVec;
1715 }
1716
1717 TEST(exstring, deliepub_command_key_string_nosame)
1718 {
1719     RedisModuleCtx ctx;
1720     //RedisModuleString str;
1721     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1722
1723     redisStrVec[0] = (RedisModuleString *)1;
1724     redisStrVec[1] = (RedisModuleString *)1;
1725     redisStrVec[2] = (RedisModuleString *)1;
1726     redisStrVec[3] = (RedisModuleString *)1;
1727     redisStrVec[4] = (RedisModuleString *)1;
1728
1729     mock().setData("RedisModule_OpenKey_have", 1);
1730     mock().setData("RedisModule_KeyType_str", 1);
1731     mock().setData("RedisModule_String_nosame", 1);
1732     mock().expectOneCall("RedisModule_CloseKey");
1733     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec, 5);
1734     CHECK_EQUAL(ret, REDISMODULE_OK);
1735     mock().checkExpectations();
1736     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1737     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1738     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1739     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1740     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1741     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1742
1743     delete []redisStrVec;
1744 }
1745
1746 TEST(exstring, deliepub_command_same_string_replynull)
1747 {
1748     RedisModuleCtx ctx;
1749     //RedisModuleString str;
1750     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1751
1752     redisStrVec[0] = (RedisModuleString *)1;
1753     redisStrVec[1] = (RedisModuleString *)1;
1754     redisStrVec[2] = (RedisModuleString *)1;
1755     redisStrVec[3] = (RedisModuleString *)1;
1756     redisStrVec[4] = (RedisModuleString *)1;
1757
1758     mock().setData("RedisModule_OpenKey_have", 1);
1759     mock().setData("RedisModule_KeyType_str", 1);
1760     mock().setData("RedisModule_String_same", 1);
1761     mock().setData("RedisModule_CallReplyType_null", 1);
1762     mock().expectOneCall("RedisModule_CloseKey");
1763     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec, 5);
1764     CHECK_EQUAL(ret, REDISMODULE_OK);
1765     mock().checkExpectations();
1766     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1767     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1768     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1769     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1770     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
1771     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
1772
1773     delete []redisStrVec;
1774 }
1775
1776 TEST(exstring, deliepub_command_same_string_reply)
1777 {
1778     RedisModuleCtx ctx;
1779     //RedisModuleString str;
1780     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1781
1782     redisStrVec[0] = (RedisModuleString *)1;
1783     redisStrVec[1] = (RedisModuleString *)1;
1784     redisStrVec[2] = (RedisModuleString *)1;
1785     redisStrVec[3] = (RedisModuleString *)1;
1786     redisStrVec[4] = (RedisModuleString *)1;
1787
1788     mock().setData("RedisModule_OpenKey_have", 1);
1789     mock().setData("RedisModule_KeyType_str", 1);
1790     mock().setData("RedisModule_String_same", 1);
1791     mock().setData("RedisModule_CallReplyType_str", 1);
1792     mock().setData("RedisModule_CallReplyInteger", 1);
1793     mock().expectOneCall("RedisModule_CloseKey");
1794     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec, 5);
1795     CHECK_EQUAL(ret, REDISMODULE_OK);
1796     mock().checkExpectations();
1797     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1798     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1799     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1800     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1801     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1802     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1803
1804     delete []redisStrVec;
1805 }
1806
1807 TEST(exstring, delnepub_command_same_string_reply)
1808 {
1809     RedisModuleCtx ctx;
1810     //RedisModuleString str;
1811     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1812
1813     redisStrVec[0] = (RedisModuleString *)1;
1814     redisStrVec[1] = (RedisModuleString *)1;
1815     redisStrVec[2] = (RedisModuleString *)1;
1816     redisStrVec[3] = (RedisModuleString *)1;
1817     redisStrVec[4] = (RedisModuleString *)1;
1818
1819     mock().setData("RedisModule_OpenKey_have", 1);
1820     mock().setData("RedisModule_KeyType_str", 1);
1821     mock().setData("RedisModule_String_same", 1);
1822     mock().setData("RedisModule_CallReplyType_str", 1);
1823     mock().expectOneCall("RedisModule_CloseKey");
1824     int ret = DelNEPub_RedisCommand(&ctx, redisStrVec, 5);
1825     CHECK_EQUAL(ret, REDISMODULE_OK);
1826     mock().checkExpectations();
1827     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1828     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1829     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1830     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1831     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1832     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1833
1834     delete []redisStrVec;
1835 }
1836
1837 TEST(exstring, delnepub_command_nosame_string_reply)
1838 {
1839     RedisModuleCtx ctx;
1840     //RedisModuleString str;
1841     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1842
1843     redisStrVec[0] = (RedisModuleString *)1;
1844     redisStrVec[1] = (RedisModuleString *)1;
1845     redisStrVec[2] = (RedisModuleString *)1;
1846     redisStrVec[3] = (RedisModuleString *)1;
1847     redisStrVec[4] = (RedisModuleString *)1;
1848
1849     mock().setData("RedisModule_OpenKey_have", 1);
1850     mock().setData("RedisModule_KeyType_str", 1);
1851     mock().setData("RedisModule_String_nosame", 1);
1852     mock().setData("RedisModule_CallReplyType_str", 1);
1853     mock().setData("RedisModule_CallReplyInteger", 1);
1854     mock().expectOneCall("RedisModule_CloseKey");
1855     int ret = DelNEPub_RedisCommand(&ctx, redisStrVec, 5);
1856     CHECK_EQUAL(ret, REDISMODULE_OK);
1857     mock().checkExpectations();
1858     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1859     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1860     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1861     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1862     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1863     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1864
1865     delete []redisStrVec;
1866 }
1867
1868 TEST(exstring, nget_command_parameter_number_incorrect)
1869 {
1870     RedisModuleCtx ctx;
1871     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1872     redisStrVec[0] = (RedisModuleString *)1;
1873     redisStrVec[1] = (RedisModuleString *)1;
1874
1875     int ret = NGet_RedisCommand(&ctx, redisStrVec,  3);
1876     CHECK_EQUAL(ret, REDISMODULE_ERR);
1877
1878     delete []redisStrVec;
1879 }
1880
1881 TEST(exstring, nget_command_zero_item)
1882 {
1883     RedisModuleCtx ctx;
1884     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1885     redisStrVec[0] = (RedisModuleString *)1;
1886     redisStrVec[1] = (RedisModuleString *)1;
1887
1888     mock().setData("RedisModule_CallReplyLength", 0);
1889     int ret = NGet_RedisCommand(&ctx, redisStrVec,  2);
1890     CHECK_EQUAL(ret, REDISMODULE_OK);
1891     CHECK_EQUAL(mock().getData("KEYS").getIntValue(), 1);
1892     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1893     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1894
1895     delete []redisStrVec;
1896 }
1897
1898 TEST(exstring, nget_command_none_zero_items)
1899 {
1900     RedisModuleCtx ctx;
1901     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1902     redisStrVec[0] = (RedisModuleString *)1;
1903     redisStrVec[1] = (RedisModuleString *)1;
1904
1905     mock().setData("RedisModule_CallReplyLength", 3);
1906     int ret = NGet_RedisCommand(&ctx, redisStrVec,  2);
1907     CHECK_EQUAL(ret, REDISMODULE_OK);
1908     CHECK_EQUAL(mock().getData("KEYS").getIntValue(), 1);
1909     CHECK_EQUAL(mock().getData("MGET").getIntValue(), 1);
1910     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithArray").getIntValue(), 3*2);
1911     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithString").getIntValue(), 3*2);
1912     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
1913
1914     delete []redisStrVec;
1915 }
1916
1917 TEST(exstring, ndel_command_parameter_parameter_number_incorrect)
1918 {
1919     RedisModuleCtx ctx;
1920     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1921     redisStrVec[0] = (RedisModuleString *)1;
1922     redisStrVec[1] = (RedisModuleString *)1;
1923
1924     int ret = NDel_RedisCommand(&ctx, redisStrVec,  3);
1925     CHECK_EQUAL(ret, REDISMODULE_ERR);
1926
1927     delete []redisStrVec;
1928 }
1929
1930 TEST(exstring, ndel_command_zero_item)
1931 {
1932     RedisModuleCtx ctx;
1933     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1934     redisStrVec[0] = (RedisModuleString *)1;
1935     redisStrVec[1] = (RedisModuleString *)1;
1936
1937     mock().setData("RedisModule_CallReplyLength", 0);
1938     int ret = NDel_RedisCommand(&ctx, redisStrVec,  2);
1939     CHECK_EQUAL(ret, REDISMODULE_OK);
1940     CHECK_EQUAL(mock().getData("KEYS").getIntValue(), 1);
1941     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1942     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1943
1944     delete []redisStrVec;
1945 }
1946
1947 TEST(exstring, ndel_command_none_zero_items)
1948 {
1949     RedisModuleCtx ctx;
1950     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1951     redisStrVec[0] = (RedisModuleString *)1;
1952     redisStrVec[1] = (RedisModuleString *)1;
1953
1954     mock().setData("RedisModule_CallReplyLength", 3);
1955     int ret = NDel_RedisCommand(&ctx, redisStrVec,  2);
1956     CHECK_EQUAL(ret, REDISMODULE_OK);
1957     CHECK_EQUAL(mock().getData("KEYS").getIntValue(), 1);
1958     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1959     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1960     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
1961
1962     delete []redisStrVec;
1963 }