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