redismodule/tst/src/exstrings_test.cpp

   1 /*
   2  * Copyright (c) 2018-2020 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
  23 extern "C" {
  24 #include "exstringsStub.h"
  25 #include "redismodule.h"
  26 }
  27
  28 #include "CppUTest/TestHarness.h"
  29 #include "CppUTestExt/MockSupport.h"
  30
  31 #define OBJ_OP_NO 0
  32 #define OBJ_OP_XX (1<<1)     /* OP if key exist */
  33 #define OBJ_OP_NX (1<<2)     /* OP if key not exist */
  34 #define OBJ_OP_IE (1<<4)     /* OP if equal old value */
  35 #define OBJ_OP_NE (1<<5)     /* OP if not equal old value */
  36
  37 typedef struct RedisModuleBlockedClientArgs {
  38     RedisModuleBlockedClient *bc;
  39     RedisModuleString **argv;
  40     int argc;
  41 } RedisModuleBlockedClientArgs;
  42
  43 TEST_GROUP(exstring)
  44 {
  45     void setup()
  46     {
  47
  48         mock().enable();
  49         mock().ignoreOtherCalls();
  50     }
  51
  52     void teardown()
  53     {
  54         mock().clear();
  55         mock().disable();
  56     }
  57
  58 };
  59
  60 TEST(exstring, OnLoad)
  61 {
  62     RedisModuleCtx ctx;
  63     int ret = RedisModule_OnLoad(&ctx, 0, 0);
  64     CHECK_EQUAL(ret, 0);
  65 }
  66
  67 TEST(exstring, setie)
  68 {
  69     RedisModuleCtx ctx;
  70     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
  71
  72     redisStrVec[0] = (RedisModuleString *)1;
  73     redisStrVec[1] = (RedisModuleString *)1;
  74     redisStrVec[2] = (RedisModuleString *)1;
  75     redisStrVec[3] = (RedisModuleString *)1;
  76
  77     mock().setData("RedisModule_OpenKey_have", 1);
  78     mock().setData("RedisModule_KeyType_str", 1);
  79     mock().setData("RedisModule_String_same", 1);
  80     mock().setData("RedisModule_CallReplyType_null", 1);
  81
  82     int ret = SetIE_RedisCommand(&ctx, redisStrVec,  4);
  83     CHECK_EQUAL(ret, 0);
  84     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
  85     delete []redisStrVec;
  86 }
  87
  88 TEST(exstring, setne)
  89 {
  90     RedisModuleCtx ctx;
  91     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
  92
  93     redisStrVec[0] = (RedisModuleString *)1;
  94     redisStrVec[1] = (RedisModuleString *)1;
  95     redisStrVec[2] = (RedisModuleString *)1;
  96     redisStrVec[3] = (RedisModuleString *)1;
  97
  98     mock().setData("RedisModule_OpenKey_have", 1);
  99     mock().setData("RedisModule_KeyType_str", 1);
 100     mock().setData("RedisModule_String_same", 1);
 101     int ret = SetNE_RedisCommand(&ctx,redisStrVec, 4);
 102     CHECK_EQUAL(ret, 0);
 103     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 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     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 265     delete []redisStrVec;
 266 }
 267
 268 TEST(exstring, delne)
 269 {
 270     RedisModuleCtx ctx;
 271     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 272
 273     redisStrVec[0] = (RedisModuleString *)1;
 274     redisStrVec[1] = (RedisModuleString *)1;
 275     redisStrVec[2] = (RedisModuleString *)1;
 276
 277     mock().setData("RedisModule_OpenKey_have", 1);
 278     mock().setData("RedisModule_KeyType_str", 1);
 279     mock().setData("RedisModule_String_same", 1);
 280     mock().expectOneCall("RedisModule_CloseKey");
 281     int ret = DelNE_RedisCommand(&ctx,redisStrVec, 3);
 282     CHECK_EQUAL(ret, 0);
 283     mock().checkExpectations();
 284     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 285     delete []redisStrVec;
 286 }
 287
 288 TEST(exstring, del_command_parameter_number_incorrect)
 289 {
 290     RedisModuleCtx ctx;
 291     int ret = 0;
 292     ret = delStringGenericCommand(&ctx, 0, 2, OBJ_OP_IE);
 293     CHECK_EQUAL(ret, 1);
 294
 295     ret = 0;
 296     ret = delStringGenericCommand(&ctx, 0, 4, OBJ_OP_NE);
 297     CHECK_EQUAL(ret, 1);
 298 }
 299
 300 TEST(exstring, delie_command_no_key)
 301 {
 302     RedisModuleCtx ctx;
 303     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 304
 305     redisStrVec[0] = (RedisModuleString *)1;
 306     redisStrVec[1] = (RedisModuleString *)1;
 307     redisStrVec[2] = (RedisModuleString *)1;
 308     mock().setData("RedisModule_OpenKey_no", 1);
 309
 310     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_IE);
 311     CHECK_EQUAL(ret, 0);
 312     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
 313     delete []redisStrVec;
 314
 315 }
 316
 317 TEST(exstring, delie_command_have_key_set)
 318 {
 319     RedisModuleCtx ctx;
 320     //RedisModuleString str;
 321     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 322
 323     redisStrVec[0] = (RedisModuleString *)1;
 324     redisStrVec[1] = (RedisModuleString *)1;
 325     redisStrVec[2] = (RedisModuleString *)1;
 326
 327     mock().setData("RedisModule_OpenKey_have", 1);
 328     mock().setData("RedisModule_KeyType_set", 1);
 329     mock().expectOneCall("RedisModule_CloseKey");
 330     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_IE);
 331     CHECK_EQUAL(ret, REDISMODULE_OK);
 332     mock().checkExpectations();
 333     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
 334     delete []redisStrVec;
 335 }
 336
 337 TEST(exstring, delie_command_key_string_nosame)
 338 {
 339     RedisModuleCtx ctx;
 340     //RedisModuleString str;
 341     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 342
 343     redisStrVec[0] = (RedisModuleString *)1;
 344     redisStrVec[1] = (RedisModuleString *)1;
 345     redisStrVec[2] = (RedisModuleString *)1;
 346
 347     mock().setData("RedisModule_OpenKey_have", 1);
 348     mock().setData("RedisModule_KeyType_str", 1);
 349
 350     mock().setData("RedisModule_String_nosame", 1);
 351
 352
 353     mock().expectOneCall("RedisModule_CloseKey");
 354     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_IE);
 355     CHECK_EQUAL(ret, 0);
 356     mock().checkExpectations();
 357     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 358     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
 359     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
 360     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
 361     delete []redisStrVec;
 362
 363 }
 364
 365
 366 TEST(exstring, delie_command_key_same_string_reply)
 367 {
 368     RedisModuleCtx ctx;
 369     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 370
 371     redisStrVec[0] = (RedisModuleString *)1;
 372     redisStrVec[1] = (RedisModuleString *)1;
 373     redisStrVec[2] = (RedisModuleString *)1;
 374
 375     mock().setData("RedisModule_OpenKey_have", 1);
 376     mock().setData("RedisModule_KeyType_str", 1);
 377     mock().setData("RedisModule_String_same", 1);
 378     mock().setData("RedisModule_CallReplyType_null", 1);
 379
 380     mock().expectOneCall("RedisModule_CloseKey");
 381     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_IE);
 382     CHECK_EQUAL(ret, 0);
 383     mock().checkExpectations();
 384     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 385     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
 386     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
 387     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 388     delete []redisStrVec;
 389 }
 390
 391
 392 TEST(exstring, delne_command_key_string_same_reply)
 393 {
 394     RedisModuleCtx ctx;
 395     //RedisModuleString str;
 396     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 397
 398     redisStrVec[0] = (RedisModuleString *)1;
 399     redisStrVec[1] = (RedisModuleString *)1;
 400     redisStrVec[2] = (RedisModuleString *)1;
 401
 402     mock().setData("RedisModule_OpenKey_have", 1);
 403     mock().setData("RedisModule_KeyType_str", 1);
 404     mock().setData("RedisModule_String_same", 1);
 405     mock().setData("RedisModule_CallReplyType_inter", 1);
 406
 407     mock().expectOneCall("RedisModule_CloseKey");
 408     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_NE);
 409     CHECK_EQUAL(ret, 0);
 410     mock().checkExpectations();
 411     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 412     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
 413     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
 414     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
 415     delete []redisStrVec;
 416
 417 }
 418
 419 TEST(exstring, delne_command_key_string_nosame_reply)
 420 {
 421     RedisModuleCtx ctx;
 422     //RedisModuleString str;
 423     RedisModuleString ** redisStrVec = new (RedisModuleString*[3]);
 424
 425     redisStrVec[0] = (RedisModuleString *)1;
 426     redisStrVec[1] = (RedisModuleString *)1;
 427     redisStrVec[2] = (RedisModuleString *)1;
 428
 429     mock().setData("RedisModule_OpenKey_have", 1);
 430     mock().setData("RedisModule_KeyType_str", 1);
 431     mock().setData("RedisModule_String_nosame", 1);
 432     mock().setData("RedisModule_CallReplyType_inter", 1);
 433
 434     mock().expectOneCall("RedisModule_CloseKey");
 435     int ret = delStringGenericCommand(&ctx, redisStrVec, 3, OBJ_OP_NE);
 436     CHECK_EQUAL(ret, 0);
 437     mock().checkExpectations();
 438     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 439     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
 440     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
 441     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 442     delete []redisStrVec;
 443
 444 }
 445
 446 TEST(exstring, setpub_command_parameter_number_incorrect)
 447 {
 448     RedisModuleCtx ctx;
 449     int ret = 0;
 450
 451     ret = SetPub_RedisCommand(&ctx, 0, 2);
 452     CHECK_EQUAL(ret, REDISMODULE_ERR);
 453
 454     ret = 0;
 455     ret = SetPub_RedisCommand(&ctx, 0, 8);
 456     CHECK_EQUAL(ret, REDISMODULE_ERR);
 457
 458     ret = 0;
 459     ret = SetMPub_RedisCommand(&ctx, 0, 2);
 460     CHECK_EQUAL(ret, REDISMODULE_ERR);
 461
 462     ret = 0;
 463     ret = SetMPub_RedisCommand(&ctx, 0, 8);
 464     CHECK_EQUAL(ret, REDISMODULE_ERR);
 465
 466     ret = 0;
 467     ret = SetXXPub_RedisCommand(&ctx, 0, 3);
 468     CHECK_EQUAL(ret, REDISMODULE_ERR);
 469
 470     ret = 0;
 471     ret = SetXXPub_RedisCommand(&ctx, 0, 6);
 472     CHECK_EQUAL(ret, REDISMODULE_ERR);
 473
 474     ret = 0;
 475     ret = SetNXPub_RedisCommand(&ctx, 0, 3);
 476     CHECK_EQUAL(ret, REDISMODULE_ERR);
 477
 478     ret = 0;
 479     ret = SetNXMPub_RedisCommand(&ctx, 0, 3);
 480     CHECK_EQUAL(ret, REDISMODULE_ERR);
 481
 482     ret = 0;
 483     ret = SetNXPub_RedisCommand(&ctx, 0, 6);
 484     CHECK_EQUAL(ret, REDISMODULE_ERR);
 485
 486     ret = 0;
 487     ret = SetIEPub_RedisCommand(&ctx, 0, 4);
 488     CHECK_EQUAL(ret, REDISMODULE_ERR);
 489
 490     ret = 0;
 491     ret = SetIEMPub_RedisCommand(&ctx, 0, 4);
 492     CHECK_EQUAL(ret, REDISMODULE_ERR);
 493
 494     ret = 0;
 495     ret = SetIEPub_RedisCommand(&ctx, 0, 9);
 496     CHECK_EQUAL(ret, REDISMODULE_ERR);
 497
 498     ret = 0;
 499     ret = SetNEPub_RedisCommand(&ctx, 0, 4);
 500     CHECK_EQUAL(ret, REDISMODULE_ERR);
 501
 502     ret = 0;
 503     ret = SetNEPub_RedisCommand(&ctx, 0, 9);
 504     CHECK_EQUAL(ret, REDISMODULE_ERR);
 505 }
 506
 507 TEST(exstring, setpub_command_no_key_replystr)
 508 {
 509     RedisModuleCtx ctx;
 510     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 511
 512     redisStrVec[0] = (RedisModuleString *)0;
 513     redisStrVec[1] = (RedisModuleString *)1;
 514     redisStrVec[2] = (RedisModuleString *)2;
 515     redisStrVec[3] = (RedisModuleString *)3;
 516     redisStrVec[4] = (RedisModuleString *)4;
 517
 518     mock().setData("RedisModule_KeyType_empty", 1);
 519     mock().setData("RedisModule_CallReplyType_str", 1);
 520
 521     int ret = SetPub_RedisCommand(&ctx, redisStrVec, 5);
 522     CHECK_EQUAL(ret, REDISMODULE_OK);
 523     mock().checkExpectations();
 524     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 525     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 526     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 527     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 528     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 529
 530     delete []redisStrVec;
 531
 532 }
 533
 534 TEST(exstring, setmpub_command_negative_key_val_count)
 535 {
 536     RedisModuleCtx ctx;
 537     RedisModuleString ** redisStrVec = new (RedisModuleString*[7]);
 538
 539     redisStrVec[0] = (RedisModuleString *)0;
 540     redisStrVec[1] = (RedisModuleString *)1;
 541     redisStrVec[2] = (RedisModuleString *)2;
 542     redisStrVec[3] = (RedisModuleString *)3;
 543     redisStrVec[4] = (RedisModuleString *)4;
 544     redisStrVec[5] = (RedisModuleString *)5;
 545     redisStrVec[6] = (RedisModuleString *)6;
 546
 547     mock().setData("RedisModule_KeyType_empty", 1);
 548     mock().setData("RedisModule_CallReplyType_str", 1);
 549     mock().setData("RedisModule_StringToLongLongCall_1", -1);
 550     mock().setData("RedisModule_StringToLongLongCall_2", 1);
 551
 552     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 7);
 553     CHECK_EQUAL(ret, REDISMODULE_OK);
 554     mock().checkExpectations();
 555     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 556     CHECK_EQUAL(0, mock().getData("MSET").getIntValue());
 557     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
 558     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
 559     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
 560     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 561
 562     delete []redisStrVec;
 563
 564 }
 565
 566 TEST(exstring, setmpub_command_negative_chan_msg_count)
 567 {
 568     RedisModuleCtx ctx;
 569     RedisModuleString ** redisStrVec = new (RedisModuleString*[7]);
 570
 571     redisStrVec[0] = (RedisModuleString *)0;
 572     redisStrVec[1] = (RedisModuleString *)1;
 573     redisStrVec[2] = (RedisModuleString *)2;
 574     redisStrVec[3] = (RedisModuleString *)3;
 575     redisStrVec[4] = (RedisModuleString *)4;
 576     redisStrVec[5] = (RedisModuleString *)5;
 577     redisStrVec[6] = (RedisModuleString *)6;
 578
 579     mock().setData("RedisModule_KeyType_empty", 1);
 580     mock().setData("RedisModule_CallReplyType_str", 1);
 581     mock().setData("RedisModule_StringToLongLongCall_1", 1);
 582     mock().setData("RedisModule_StringToLongLongCall_2", -1);
 583
 584     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 7);
 585     CHECK_EQUAL(ret, REDISMODULE_OK);
 586     mock().checkExpectations();
 587     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 588     CHECK_EQUAL(0, mock().getData("MSET").getIntValue());
 589     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
 590     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
 591     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
 592     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 593
 594     delete []redisStrVec;
 595
 596 }
 597
 598 TEST(exstring, setmpub_command_invalid_total_count)
 599 {
 600     RedisModuleCtx ctx;
 601     RedisModuleString ** redisStrVec = new (RedisModuleString*[7]);
 602
 603     redisStrVec[0] = (RedisModuleString *)0;
 604     redisStrVec[1] = (RedisModuleString *)1;
 605     redisStrVec[2] = (RedisModuleString *)2;
 606     redisStrVec[3] = (RedisModuleString *)3;
 607     redisStrVec[4] = (RedisModuleString *)4;
 608     redisStrVec[5] = (RedisModuleString *)5;
 609     redisStrVec[6] = (RedisModuleString *)6;
 610
 611     mock().setData("RedisModule_KeyType_empty", 1);
 612     mock().setData("RedisModule_CallReplyType_str", 1);
 613     mock().setData("RedisModule_StringToLongLongCall_1", 100);
 614     mock().setData("RedisModule_StringToLongLongCall_2", 100);
 615
 616     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 7);
 617     CHECK_EQUAL(ret, REDISMODULE_OK);
 618     mock().checkExpectations();
 619     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 620     CHECK_EQUAL(0, mock().getData("MSET").getIntValue());
 621     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
 622     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
 623     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
 624     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 625
 626     delete []redisStrVec;
 627
 628 }
 629
 630 TEST(exstring, setmpub_command_set)
 631 {
 632     RedisModuleCtx ctx;
 633     RedisModuleString ** redisStrVec = new (RedisModuleString*[7]);
 634
 635     redisStrVec[0] = (RedisModuleString *)0;
 636     redisStrVec[1] = (RedisModuleString *)1;
 637     redisStrVec[2] = (RedisModuleString *)2;
 638     redisStrVec[3] = (RedisModuleString *)3;
 639     redisStrVec[4] = (RedisModuleString *)4;
 640     redisStrVec[5] = (RedisModuleString *)5;
 641     redisStrVec[6] = (RedisModuleString *)6;
 642
 643     mock().setData("RedisModule_KeyType_empty", 1);
 644     mock().setData("RedisModule_CallReplyType_str", 1);
 645     mock().setData("RedisModule_StringToLongLongCall_1", 1);
 646     mock().setData("RedisModule_StringToLongLongCall_2", 1);
 647
 648     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 7);
 649     CHECK_EQUAL(ret, REDISMODULE_OK);
 650     mock().checkExpectations();
 651     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 652     CHECK_EQUAL(1, mock().getData("MSET").getIntValue());
 653     CHECK_EQUAL(1, mock().getData("PUBLISH").getIntValue());
 654     CHECK_EQUAL(2, mock().getData("RedisModule_FreeCallReply").getIntValue());
 655     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 656
 657     delete []redisStrVec;
 658
 659 }
 660
 661 TEST(exstring, setmpub_command_set_multipub)
 662 {
 663     RedisModuleCtx ctx;
 664     RedisModuleString ** redisStrVec = new (RedisModuleString*[9]);
 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     redisStrVec[5] = (RedisModuleString *)5;
 672     redisStrVec[6] = (RedisModuleString *)6;
 673     redisStrVec[7] = (RedisModuleString *)7;
 674     redisStrVec[8] = (RedisModuleString *)8;
 675
 676     mock().setData("RedisModule_KeyType_empty", 1);
 677     mock().setData("RedisModule_CallReplyType_str", 1);
 678     mock().setData("RedisModule_StringToLongLongCall_1", 1);
 679     mock().setData("RedisModule_StringToLongLongCall_2", 2);
 680
 681     int ret = SetMPub_RedisCommand(&ctx, redisStrVec, 9);
 682     CHECK_EQUAL(ret, REDISMODULE_OK);
 683     mock().checkExpectations();
 684     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
 685     CHECK_EQUAL(1, mock().getData("MSET").getIntValue());
 686     CHECK_EQUAL(2, mock().getData("PUBLISH").getIntValue());
 687     CHECK_EQUAL(3, mock().getData("RedisModule_FreeCallReply").getIntValue());
 688     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 689
 690     delete []redisStrVec;
 691
 692 }
 693
 694 TEST(exstring, setxxpub_command_has_no_key)
 695 {
 696     RedisModuleCtx ctx;
 697     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 698
 699     redisStrVec[0] = (RedisModuleString *)0;
 700     redisStrVec[1] = (RedisModuleString *)1;
 701     redisStrVec[2] = (RedisModuleString *)2;
 702     redisStrVec[3] = (RedisModuleString *)3;
 703     redisStrVec[4] = (RedisModuleString *)4;
 704
 705     mock().setData("RedisModule_KeyType_empty", 1);
 706     mock().setData("RedisModule_CallReplyType_null", 1);
 707
 708     mock().expectOneCall("RedisModule_CloseKey");
 709     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec, 5);
 710
 711     CHECK_EQUAL(ret, REDISMODULE_OK);
 712     mock().checkExpectations();
 713     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 714     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 715     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 716     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 717     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 718     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 719
 720     delete []redisStrVec;
 721
 722 }
 723
 724 TEST(exstring, setxxpub_command_parameter_has_key_set)
 725 {
 726     RedisModuleCtx ctx;
 727     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 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
 735     mock().setData("RedisModule_KeyType_set", 1);
 736
 737     mock().expectOneCall("RedisModule_CloseKey");
 738     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec, 5);
 739
 740     CHECK_EQUAL(ret, REDISMODULE_OK);
 741     mock().checkExpectations();
 742     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
 743     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 744     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 745     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 746     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 747     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 748
 749     delete []redisStrVec;
 750
 751 }
 752
 753 TEST(exstring, setxxpub_command_has_key_string)
 754 {
 755     RedisModuleCtx ctx;
 756     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 757
 758     redisStrVec[0] = (RedisModuleString *)0;
 759     redisStrVec[1] = (RedisModuleString *)1;
 760     redisStrVec[2] = (RedisModuleString *)2;
 761     redisStrVec[3] = (RedisModuleString *)3;
 762     redisStrVec[4] = (RedisModuleString *)4;
 763
 764     mock().setData("RedisModule_KeyType_str", 1);
 765     mock().setData("RedisModule_CallReplyType_str", 1);
 766
 767     mock().expectOneCall("RedisModule_CloseKey");
 768     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec, 5);
 769
 770     CHECK_EQUAL(ret, REDISMODULE_OK);
 771     mock().checkExpectations();
 772     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
 773     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 774     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 775     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 776     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 777     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 778
 779     delete []redisStrVec;
 780
 781 }
 782
 783
 784 TEST(exstring, setnxpub_command_has_key_string)
 785 {
 786     RedisModuleCtx ctx;
 787     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 788
 789     redisStrVec[0] = (RedisModuleString *)0;
 790     redisStrVec[1] = (RedisModuleString *)1;
 791     redisStrVec[2] = (RedisModuleString *)2;
 792     redisStrVec[3] = (RedisModuleString *)3;
 793     redisStrVec[4] = (RedisModuleString *)4;
 794
 795     mock().setData("RedisModule_KeyType_str", 1);
 796     mock().setData("RedisModule_CallReplyType_null", 1);
 797
 798     mock().expectOneCall("RedisModule_CloseKey");
 799     int ret = SetNXPub_RedisCommand(&ctx, redisStrVec, 5);
 800
 801     CHECK_EQUAL(ret, REDISMODULE_OK);
 802     mock().checkExpectations();
 803     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 804     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 805     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 806     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 807     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 808     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 809
 810     delete []redisStrVec;
 811
 812 }
 813
 814 TEST(exstring, setnxpub_command_has_no_key)
 815 {
 816     RedisModuleCtx ctx;
 817     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 818
 819     redisStrVec[0] = (RedisModuleString *)0;
 820     redisStrVec[1] = (RedisModuleString *)1;
 821     redisStrVec[2] = (RedisModuleString *)2;
 822     redisStrVec[3] = (RedisModuleString *)3;
 823     redisStrVec[4] = (RedisModuleString *)4;
 824
 825     mock().setData("RedisModule_KeyType_empty", 1);
 826     mock().setData("RedisModule_CallReplyType_str", 1);
 827
 828     mock().expectOneCall("RedisModule_CloseKey");
 829     int ret = SetNXPub_RedisCommand(&ctx, redisStrVec, 5);
 830
 831     CHECK_EQUAL(ret, REDISMODULE_OK);
 832     mock().checkExpectations();
 833     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
 834     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 835     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 836     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 837     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 838     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 839
 840     delete []redisStrVec;
 841
 842 }
 843
 844
 845
 846 TEST(exstring, setiepub_command_has_no_key)
 847 {
 848     RedisModuleCtx ctx;
 849     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 850
 851     redisStrVec[0] = (RedisModuleString *)0;
 852     redisStrVec[1] = (RedisModuleString *)1;
 853     redisStrVec[2] = (RedisModuleString *)2;
 854     redisStrVec[3] = (RedisModuleString *)3;
 855     redisStrVec[4] = (RedisModuleString *)4;
 856     redisStrVec[5] = (RedisModuleString *)5;
 857
 858     mock().setData("RedisModule_KeyType_empty", 1);
 859     mock().setData("RedisModule_CallReplyType_str", 1);
 860
 861     mock().expectOneCall("RedisModule_CloseKey");
 862     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
 863
 864     CHECK_EQUAL(ret, REDISMODULE_OK);
 865     mock().checkExpectations();
 866     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 867     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 868     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 869     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 870     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 871     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 872
 873     delete []redisStrVec;
 874
 875 }
 876
 877
 878 TEST(exstring, setiepub_command_key_string_nosame)
 879 {
 880     RedisModuleCtx ctx;
 881     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 882
 883     redisStrVec[0] = (RedisModuleString *)0;
 884     redisStrVec[1] = (RedisModuleString *)1;
 885     redisStrVec[2] = (RedisModuleString *)2;
 886     redisStrVec[3] = (RedisModuleString *)3;
 887     redisStrVec[4] = (RedisModuleString *)4;
 888     redisStrVec[5] = (RedisModuleString *)5;
 889
 890     mock().setData("RedisModule_KeyType_str", 1);
 891     mock().setData("RedisModule_CallReplyType_str", 1);
 892     mock().setData("RedisModule_String_nosame", 1);
 893
 894     mock().expectOneCall("RedisModule_CloseKey");
 895     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
 896
 897     CHECK_EQUAL(ret, REDISMODULE_OK);
 898     mock().checkExpectations();
 899     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 900     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 901     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 902     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 903     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
 904     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 905
 906     delete []redisStrVec;
 907
 908 }
 909
 910 TEST(exstring, setiepub_command_key_same_string_reply)
 911 {
 912     RedisModuleCtx ctx;
 913     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 914
 915     redisStrVec[0] = (RedisModuleString *)0;
 916     redisStrVec[1] = (RedisModuleString *)1;
 917     redisStrVec[2] = (RedisModuleString *)2;
 918     redisStrVec[3] = (RedisModuleString *)3;
 919     redisStrVec[4] = (RedisModuleString *)4;
 920     redisStrVec[5] = (RedisModuleString *)5;
 921
 922     mock().setData("RedisModule_KeyType_str", 1);
 923     mock().setData("RedisModule_String_same", 1);
 924     mock().setData("RedisModule_CallReplyType_str", 1);
 925
 926     mock().expectOneCall("RedisModule_CloseKey");
 927     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
 928
 929     CHECK_EQUAL(ret, REDISMODULE_OK);
 930     mock().checkExpectations();
 931     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 932     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 933     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 934     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
 935     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
 936     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 937
 938     delete []redisStrVec;
 939
 940 }
 941
 942 TEST(exstring, setnepub_command_has_no_key)
 943 {
 944     RedisModuleCtx ctx;
 945     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 946
 947     redisStrVec[0] = (RedisModuleString *)0;
 948     redisStrVec[1] = (RedisModuleString *)1;
 949     redisStrVec[2] = (RedisModuleString *)2;
 950     redisStrVec[3] = (RedisModuleString *)3;
 951     redisStrVec[4] = (RedisModuleString *)4;
 952     redisStrVec[5] = (RedisModuleString *)5;
 953
 954     mock().setData("RedisModule_KeyType_empty", 1);
 955     mock().setData("RedisModule_CallReplyType_str", 1);
 956     mock().setData("RedisModule_String_nosame", 1);
 957
 958     mock().expectOneCall("RedisModule_CloseKey");
 959     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec, 6);
 960
 961     CHECK_EQUAL(ret, REDISMODULE_OK);
 962     mock().checkExpectations();
 963     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 964     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 965     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 966     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
 967     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
 968     CHECK_EQUAL(mock().getData("RedisModule_AutoMemory").getIntValue(),1);
 969
 970     delete []redisStrVec;
 971
 972 }
 973
 974 TEST(exstring, setnepub_command_key_string_same_reply)
 975 {
 976     RedisModuleCtx ctx;
 977     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 978
 979     redisStrVec[0] = (RedisModuleString *)0;
 980     redisStrVec[1] = (RedisModuleString *)1;
 981     redisStrVec[2] = (RedisModuleString *)2;
 982     redisStrVec[3] = (RedisModuleString *)3;
 983     redisStrVec[4] = (RedisModuleString *)4;
 984     redisStrVec[5] = (RedisModuleString *)5;
 985
 986     mock().setData("RedisModule_KeyType_str", 1);
 987     mock().setData("RedisModule_String_same", 1);
 988     mock().setData("RedisModule_CallReplyType_str", 1);
 989
 990     mock().expectOneCall("RedisModule_CloseKey");
 991     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec, 6);
 992
 993     CHECK_EQUAL(ret, REDISMODULE_OK);
 994     mock().checkExpectations();
 995     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 996     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 997     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 998     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 999     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1000
1001     delete []redisStrVec;
1002
1003 }
1004
1005
1006 TEST(exstring, setnepub_command_key_string_nosame_reply)
1007 {
1008     RedisModuleCtx ctx;
1009     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
1010
1011     redisStrVec[0] = (RedisModuleString *)0;
1012     redisStrVec[1] = (RedisModuleString *)1;
1013     redisStrVec[2] = (RedisModuleString *)2;
1014     redisStrVec[3] = (RedisModuleString *)3;
1015     redisStrVec[4] = (RedisModuleString *)4;
1016     redisStrVec[5] = (RedisModuleString *)5;
1017
1018     mock().setData("RedisModule_KeyType_str", 1);
1019     mock().setData("RedisModule_CallReplyType_str", 1);
1020     mock().setData("RedisModule_String_nosame", 1);
1021
1022     mock().expectOneCall("RedisModule_CloseKey");
1023     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec, 6);
1024
1025     CHECK_EQUAL(ret, REDISMODULE_OK);
1026     mock().checkExpectations();
1027     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1028     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
1029     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1030     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1031     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1032
1033     delete []redisStrVec;
1034
1035 }
1036
1037 TEST(exstring, delpub)
1038 {
1039     RedisModuleCtx ctx;
1040     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
1041
1042     redisStrVec[0] = (RedisModuleString *)1;
1043     redisStrVec[1] = (RedisModuleString *)1;
1044     redisStrVec[2] = (RedisModuleString *)1;
1045     redisStrVec[3] = (RedisModuleString *)1;
1046
1047     mock().setData("RedisModule_OpenKey_have", 1);
1048     mock().setData("RedisModule_KeyType_str", 1);
1049     mock().setData("RedisModule_String_same", 1);
1050     mock().setData("RedisModule_CallReplyType_null", 1);
1051
1052     int ret = DelPub_RedisCommand(&ctx, redisStrVec,  4);
1053     CHECK_EQUAL(ret, REDISMODULE_OK);
1054
1055     delete []redisStrVec;
1056 }
1057
1058 TEST(exstring, delmpub)
1059 {
1060     RedisModuleCtx ctx;
1061     RedisModuleString ** redisStrVec = new (RedisModuleString*[8]);
1062
1063     redisStrVec[0] = (RedisModuleString *)1;
1064     redisStrVec[1] = (RedisModuleString *)1;
1065     redisStrVec[2] = (RedisModuleString *)1;
1066     redisStrVec[3] = (RedisModuleString *)1;
1067     redisStrVec[4] = (RedisModuleString *)1;
1068     redisStrVec[5] = (RedisModuleString *)1;
1069     redisStrVec[6] = (RedisModuleString *)1;
1070     redisStrVec[7] = (RedisModuleString *)1;
1071
1072     mock().setData("RedisModule_OpenKey_have", 1);
1073     mock().setData("RedisModule_KeyType_str", 1);
1074     mock().setData("RedisModule_String_same", 1);
1075     mock().setData("RedisModule_CallReplyType_null", 1);
1076     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1077     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1078     mock().setData("RedisModule_StringToLongLongCall_2", 2);
1079
1080     int ret = DelMPub_RedisCommand(&ctx, redisStrVec,  8);
1081     CHECK_EQUAL(ret, REDISMODULE_OK);
1082
1083     delete []redisStrVec;
1084 }
1085
1086 TEST(exstring, deliepub)
1087 {
1088     RedisModuleCtx ctx;
1089     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1090
1091     redisStrVec[0] = (RedisModuleString *)1;
1092     redisStrVec[1] = (RedisModuleString *)1;
1093     redisStrVec[2] = (RedisModuleString *)1;
1094     redisStrVec[3] = (RedisModuleString *)1;
1095     redisStrVec[4] = (RedisModuleString *)1;
1096
1097     mock().setData("RedisModule_OpenKey_have", 1);
1098     mock().setData("RedisModule_KeyType_str", 1);
1099     mock().setData("RedisModule_String_same", 1);
1100     mock().setData("RedisModule_CallReplyType_null", 1);
1101
1102     mock().expectOneCall("RedisModule_CloseKey");
1103     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec,  5);
1104     CHECK_EQUAL(ret, REDISMODULE_OK);
1105     mock().checkExpectations();
1106     delete []redisStrVec;
1107 }
1108
1109 TEST(exstring, deliempub)
1110 {
1111     RedisModuleCtx ctx;
1112     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1113
1114     redisStrVec[0] = (RedisModuleString *)1;
1115     redisStrVec[1] = (RedisModuleString *)1;
1116     redisStrVec[2] = (RedisModuleString *)1;
1117     redisStrVec[3] = (RedisModuleString *)1;
1118     redisStrVec[4] = (RedisModuleString *)1;
1119
1120     mock().setData("RedisModule_OpenKey_have", 1);
1121     mock().setData("RedisModule_KeyType_str", 1);
1122     mock().setData("RedisModule_String_same", 1);
1123     mock().setData("RedisModule_CallReplyType_null", 1);
1124
1125     mock().expectOneCall("RedisModule_CloseKey");
1126     int ret = DelIEMPub_RedisCommand(&ctx, redisStrVec,  5);
1127     CHECK_EQUAL(ret, REDISMODULE_OK);
1128     mock().checkExpectations();
1129     delete []redisStrVec;
1130 }
1131
1132 TEST(exstring, delnepub)
1133 {
1134     RedisModuleCtx ctx;
1135     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1136
1137     redisStrVec[0] = (RedisModuleString *)1;
1138     redisStrVec[1] = (RedisModuleString *)1;
1139     redisStrVec[2] = (RedisModuleString *)1;
1140     redisStrVec[3] = (RedisModuleString *)1;
1141     redisStrVec[4] = (RedisModuleString *)1;
1142
1143     mock().setData("RedisModule_OpenKey_have", 1);
1144     mock().setData("RedisModule_KeyType_str", 1);
1145     mock().setData("RedisModule_String_same", 1);
1146     mock().setData("RedisModule_CallReplyType_null", 1);
1147
1148     mock().expectOneCall("RedisModule_CloseKey");
1149     int ret = DelNEPub_RedisCommand(&ctx, redisStrVec,  5);
1150     CHECK_EQUAL(ret, REDISMODULE_OK);
1151     mock().checkExpectations();
1152     delete []redisStrVec;
1153 }
1154
1155 TEST(exstring, delpub_command_parameter_number_incorrect)
1156 {
1157     RedisModuleCtx ctx;
1158     int ret = 0;
1159     ret = DelPub_RedisCommand(&ctx, 0, 2);
1160     CHECK_EQUAL(ret, REDISMODULE_ERR);
1161
1162     ret = 0;
1163     ret = DelMPub_RedisCommand(&ctx, 0, 5);
1164     CHECK_EQUAL(ret, REDISMODULE_ERR);
1165
1166     ret = 0;
1167     ret = DelIEPub_RedisCommand(&ctx, 0, 4);
1168     CHECK_EQUAL(ret, REDISMODULE_ERR);
1169
1170     ret = 0;
1171     ret = DelIEMPub_RedisCommand(&ctx, 0, 4);
1172     CHECK_EQUAL(ret, REDISMODULE_ERR);
1173
1174     ret = 0;
1175     ret = DelNEPub_RedisCommand(&ctx, 0, 8);
1176     CHECK_EQUAL(ret, REDISMODULE_ERR);
1177 }
1178
1179 TEST(exstring, delpub_command_reply_null)
1180 {
1181     RedisModuleCtx ctx;
1182     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1183
1184     redisStrVec[0] = (RedisModuleString *)1;
1185     redisStrVec[1] = (RedisModuleString *)1;
1186     redisStrVec[2] = (RedisModuleString *)1;
1187     redisStrVec[3] = (RedisModuleString *)1;
1188     redisStrVec[4] = (RedisModuleString *)1;
1189     mock().setData("RedisModule_CallReplyInteger", 0);
1190     mock().setData("RedisModule_CallReplyType_inter", 1);
1191     mock().setData("RedisModule_Call_Return_Null", 0);
1192
1193     int ret = DelPub_RedisCommand(&ctx, redisStrVec, 5);
1194     CHECK_EQUAL(ret, 0);
1195     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1196     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1197     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1198     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 0);
1199     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1200     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
1201     delete []redisStrVec;
1202
1203 }
1204
1205 TEST(exstring, delpub_command_reply_error)
1206 {
1207     RedisModuleCtx ctx;
1208     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1209
1210     redisStrVec[0] = (RedisModuleString *)1;
1211     redisStrVec[1] = (RedisModuleString *)1;
1212     redisStrVec[2] = (RedisModuleString *)1;
1213     redisStrVec[3] = (RedisModuleString *)1;
1214     redisStrVec[4] = (RedisModuleString *)1;
1215     mock().setData("RedisModule_CallReplyInteger", 0);
1216     mock().setData("RedisModule_CallReplyType_err", 1);
1217
1218     int ret = DelPub_RedisCommand(&ctx, redisStrVec, 5);
1219     CHECK_EQUAL(ret, REDISMODULE_OK);
1220     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1221     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1222     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1223     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1224     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1225     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1226     delete []redisStrVec;
1227
1228 }
1229
1230 TEST(exstring, delpub_command_has_no_key)
1231 {
1232     RedisModuleCtx ctx;
1233     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1234
1235     redisStrVec[0] = (RedisModuleString *)1;
1236     redisStrVec[1] = (RedisModuleString *)1;
1237     redisStrVec[2] = (RedisModuleString *)1;
1238     redisStrVec[3] = (RedisModuleString *)1;
1239     redisStrVec[4] = (RedisModuleString *)1;
1240     mock().setData("RedisModule_CallReplyInteger", 0);
1241     mock().setData("RedisModule_CallReplyType_inter", 1);
1242
1243     int ret = DelPub_RedisCommand(&ctx, redisStrVec, 5);
1244     CHECK_EQUAL(ret, 0);
1245     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1246     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1247     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1248     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1249     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1250     delete []redisStrVec;
1251
1252 }
1253
1254 TEST(exstring, delmpub_command_reply_null)
1255 {
1256     RedisModuleCtx ctx;
1257     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1258
1259     redisStrVec[0] = (RedisModuleString *)1;
1260     redisStrVec[1] = (RedisModuleString *)1;
1261     redisStrVec[2] = (RedisModuleString *)1;
1262     redisStrVec[3] = (RedisModuleString *)1;
1263     redisStrVec[4] = (RedisModuleString *)1;
1264     redisStrVec[5] = (RedisModuleString *)1;
1265
1266     mock().setData("RedisModule_Call_Return_Null", 1);
1267     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1268     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1269     mock().setData("RedisModule_StringToLongLongCall_2", 1);
1270
1271     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1272     CHECK_EQUAL(ret, 0);
1273     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1274     CHECK_EQUAL(1, mock().getData("UNLINK").getIntValue());
1275     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
1276     CHECK_EQUAL(0, mock().getData("RedisModule_ReplyWithCallReply").getIntValue());
1277     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
1278     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
1279     delete []redisStrVec;
1280
1281 }
1282
1283 TEST(exstring, delmpub_command_reply_error)
1284 {
1285     RedisModuleCtx ctx;
1286     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1287
1288     redisStrVec[0] = (RedisModuleString *)1;
1289     redisStrVec[1] = (RedisModuleString *)1;
1290     redisStrVec[2] = (RedisModuleString *)1;
1291     redisStrVec[3] = (RedisModuleString *)1;
1292     redisStrVec[4] = (RedisModuleString *)1;
1293     redisStrVec[4] = (RedisModuleString *)1;
1294
1295     mock().setData("RedisModule_CallReplyInteger", 0);
1296     mock().setData("RedisModule_CallReplyType_err", 1);
1297     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1298     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1299     mock().setData("RedisModule_StringToLongLongCall_2", 1);
1300
1301     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1302     CHECK_EQUAL(ret, REDISMODULE_OK);
1303     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1304     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1305     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1306     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1307     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1308     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1309     delete []redisStrVec;
1310
1311 }
1312
1313 TEST(exstring, delmpub_command_has_no_key)
1314 {
1315     RedisModuleCtx ctx;
1316     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1317
1318     redisStrVec[0] = (RedisModuleString *)1;
1319     redisStrVec[1] = (RedisModuleString *)1;
1320     redisStrVec[2] = (RedisModuleString *)1;
1321     redisStrVec[3] = (RedisModuleString *)1;
1322     redisStrVec[4] = (RedisModuleString *)1;
1323     redisStrVec[5] = (RedisModuleString *)1;
1324
1325     mock().setData("RedisModule_CallReplyInteger", 0);
1326     mock().setData("RedisModule_CallReplyType_inter", 1);
1327     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1328     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1329     mock().setData("RedisModule_StringToLongLongCall_2", 1);
1330
1331     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1332     CHECK_EQUAL(ret, 0);
1333     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1334     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1335     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1336     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1337     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1338     delete []redisStrVec;
1339
1340 }
1341
1342 TEST(exstring, delmpub_command_key_deleted)
1343 {
1344     RedisModuleCtx ctx;
1345     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1346
1347     redisStrVec[0] = (RedisModuleString *)1;
1348     redisStrVec[1] = (RedisModuleString *)1;
1349     redisStrVec[2] = (RedisModuleString *)1;
1350     redisStrVec[3] = (RedisModuleString *)1;
1351     redisStrVec[4] = (RedisModuleString *)1;
1352     redisStrVec[5] = (RedisModuleString *)1;
1353
1354     mock().setData("RedisModule_CallReplyInteger", 1);
1355     mock().setData("RedisModule_CallReplyType_inter", 1);
1356     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1357     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1358     mock().setData("RedisModule_StringToLongLongCall_2", 1);
1359
1360     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1361     CHECK_EQUAL(ret, 0);
1362     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1363     CHECK_EQUAL(1, mock().getData("UNLINK").getIntValue());
1364     CHECK_EQUAL(1, mock().getData("PUBLISH").getIntValue());
1365     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithCallReply").getIntValue());
1366     CHECK_EQUAL(2, mock().getData("RedisModule_FreeCallReply").getIntValue());
1367     delete []redisStrVec;
1368
1369 }
1370
1371 TEST(exstring, delmpub_command_key_deleted_multi_pub)
1372 {
1373     RedisModuleCtx ctx;
1374     RedisModuleString **redisStrVec = new (RedisModuleString*[10]);
1375
1376     redisStrVec[0] = (RedisModuleString *)1;
1377     redisStrVec[1] = (RedisModuleString *)1;
1378     redisStrVec[2] = (RedisModuleString *)1;
1379     redisStrVec[3] = (RedisModuleString *)1;
1380     redisStrVec[4] = (RedisModuleString *)1;
1381     redisStrVec[5] = (RedisModuleString *)1;
1382     redisStrVec[6] = (RedisModuleString *)1;
1383     redisStrVec[7] = (RedisModuleString *)1;
1384     redisStrVec[8] = (RedisModuleString *)1;
1385     redisStrVec[9] = (RedisModuleString *)1;
1386
1387     mock().setData("RedisModule_CallReplyInteger", 1);
1388     mock().setData("RedisModule_CallReplyType_inter", 1);
1389     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1390     mock().setData("RedisModule_StringToLongLongCall_1", 1);
1391     mock().setData("RedisModule_StringToLongLongCall_2", 3);
1392
1393     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 10);
1394     CHECK_EQUAL(0, ret);
1395     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1396     CHECK_EQUAL(1, mock().getData("UNLINK").getIntValue());
1397     CHECK_EQUAL(3, mock().getData("PUBLISH").getIntValue());
1398     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithCallReply").getIntValue());
1399     CHECK_EQUAL(4, mock().getData("RedisModule_FreeCallReply").getIntValue());
1400     delete []redisStrVec;
1401
1402 }
1403
1404 TEST(exstring, delmpub_command_negative_del_count)
1405 {
1406     RedisModuleCtx ctx;
1407     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1408
1409     redisStrVec[0] = (RedisModuleString *)1;
1410     redisStrVec[1] = (RedisModuleString *)1;
1411     redisStrVec[2] = (RedisModuleString *)1;
1412     redisStrVec[3] = (RedisModuleString *)1;
1413     redisStrVec[4] = (RedisModuleString *)1;
1414     redisStrVec[5] = (RedisModuleString *)1;
1415
1416     mock().setData("RedisModule_CallReplyInteger", 1);
1417     mock().setData("RedisModule_CallReplyType_inter", 1);
1418     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1419     mock().setData("RedisModule_StringToLongLongCall_1", -1);
1420     mock().setData("RedisModule_StringToLongLongCall_2", 1);
1421
1422     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1423     CHECK_EQUAL(0, ret);
1424     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1425     CHECK_EQUAL(0, mock().getData("UNLINK").getIntValue());
1426     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
1427     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
1428     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
1429     delete []redisStrVec;
1430
1431 }
1432
1433 TEST(exstring, delmpub_command_negative_chan_msg_count)
1434 {
1435     RedisModuleCtx ctx;
1436     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1437
1438     redisStrVec[0] = (RedisModuleString *)1;
1439     redisStrVec[1] = (RedisModuleString *)1;
1440     redisStrVec[2] = (RedisModuleString *)1;
1441     redisStrVec[3] = (RedisModuleString *)1;
1442     redisStrVec[4] = (RedisModuleString *)1;
1443     redisStrVec[5] = (RedisModuleString *)1;
1444
1445     mock().setData("RedisModule_CallReplyInteger", 1);
1446     mock().setData("RedisModule_CallReplyType_inter", 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(0, ret);
1453     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1454     CHECK_EQUAL(0, mock().getData("UNLINK").getIntValue());
1455     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
1456     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
1457     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
1458     delete []redisStrVec;
1459
1460 }
1461
1462 TEST(exstring, delmpub_command_invalid_total_count)
1463 {
1464     RedisModuleCtx ctx;
1465     RedisModuleString **redisStrVec = new (RedisModuleString*[6]);
1466
1467     redisStrVec[0] = (RedisModuleString *)1;
1468     redisStrVec[1] = (RedisModuleString *)1;
1469     redisStrVec[2] = (RedisModuleString *)1;
1470     redisStrVec[3] = (RedisModuleString *)1;
1471     redisStrVec[4] = (RedisModuleString *)1;
1472     redisStrVec[5] = (RedisModuleString *)1;
1473
1474     mock().setData("RedisModule_CallReplyInteger", 1);
1475     mock().setData("RedisModule_CallReplyType_inter", 1);
1476     mock().setData("RedisModule_StringToLongLongCallCount", 0);
1477     mock().setData("RedisModule_StringToLongLongCall_1", 100);
1478     mock().setData("RedisModule_StringToLongLongCall_2", 100);
1479
1480     int ret = DelMPub_RedisCommand(&ctx, redisStrVec, 6);
1481     CHECK_EQUAL(0, ret);
1482     CHECK_EQUAL(0, mock().getData("GET").getIntValue());
1483     CHECK_EQUAL(0, mock().getData("UNLINK").getIntValue());
1484     CHECK_EQUAL(0, mock().getData("PUBLISH").getIntValue());
1485     CHECK_EQUAL(1, mock().getData("RedisModule_ReplyWithError").getIntValue());
1486     CHECK_EQUAL(0, mock().getData("RedisModule_FreeCallReply").getIntValue());
1487     delete []redisStrVec;
1488
1489 }
1490
1491 TEST(exstring, deliepub_command_has_no_key)
1492 {
1493     RedisModuleCtx ctx;
1494     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1495
1496     redisStrVec[0] = (RedisModuleString *)1;
1497     redisStrVec[1] = (RedisModuleString *)1;
1498     redisStrVec[2] = (RedisModuleString *)1;
1499     redisStrVec[3] = (RedisModuleString *)1;
1500     redisStrVec[4] = (RedisModuleString *)1;
1501     mock().setData("RedisModule_KeyType_empty", 1);
1502
1503     mock().expectOneCall("RedisModule_CloseKey");
1504     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec, 5);
1505     CHECK_EQUAL(ret, 0);
1506     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1507     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1508     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1509     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1510     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1511     delete []redisStrVec;
1512
1513 }
1514
1515 TEST(exstring, deliepub_command_has_key_set)
1516 {
1517     RedisModuleCtx ctx;
1518     //RedisModuleString str;
1519     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1520
1521     redisStrVec[0] = (RedisModuleString *)1;
1522     redisStrVec[1] = (RedisModuleString *)1;
1523     redisStrVec[2] = (RedisModuleString *)1;
1524     redisStrVec[3] = (RedisModuleString *)1;
1525     redisStrVec[4] = (RedisModuleString *)1;
1526
1527     mock().setData("RedisModule_OpenKey_have", 1);
1528     mock().setData("RedisModule_KeyType_set", 1);
1529     mock().expectOneCall("RedisModule_CloseKey");
1530     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec, 5);
1531     CHECK_EQUAL(ret, REDISMODULE_OK);
1532     mock().checkExpectations();
1533     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
1534     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1535     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1536     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1537     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1538
1539     delete []redisStrVec;
1540 }
1541
1542 TEST(exstring, deliepub_command_key_string_nosame)
1543 {
1544     RedisModuleCtx ctx;
1545     //RedisModuleString str;
1546     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1547
1548     redisStrVec[0] = (RedisModuleString *)1;
1549     redisStrVec[1] = (RedisModuleString *)1;
1550     redisStrVec[2] = (RedisModuleString *)1;
1551     redisStrVec[3] = (RedisModuleString *)1;
1552     redisStrVec[4] = (RedisModuleString *)1;
1553
1554     mock().setData("RedisModule_OpenKey_have", 1);
1555     mock().setData("RedisModule_KeyType_str", 1);
1556     mock().setData("RedisModule_String_nosame", 1);
1557     mock().expectOneCall("RedisModule_CloseKey");
1558     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec, 5);
1559     CHECK_EQUAL(ret, REDISMODULE_OK);
1560     mock().checkExpectations();
1561     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1562     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1563     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1564     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1565     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1566     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1567
1568     delete []redisStrVec;
1569 }
1570
1571 TEST(exstring, deliepub_command_same_string_replynull)
1572 {
1573     RedisModuleCtx ctx;
1574     //RedisModuleString str;
1575     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1576
1577     redisStrVec[0] = (RedisModuleString *)1;
1578     redisStrVec[1] = (RedisModuleString *)1;
1579     redisStrVec[2] = (RedisModuleString *)1;
1580     redisStrVec[3] = (RedisModuleString *)1;
1581     redisStrVec[4] = (RedisModuleString *)1;
1582
1583     mock().setData("RedisModule_OpenKey_have", 1);
1584     mock().setData("RedisModule_KeyType_str", 1);
1585     mock().setData("RedisModule_String_same", 1);
1586     mock().setData("RedisModule_CallReplyType_null", 1);
1587     mock().expectOneCall("RedisModule_CloseKey");
1588     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec, 5);
1589     CHECK_EQUAL(ret, REDISMODULE_OK);
1590     mock().checkExpectations();
1591     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1592     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1593     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1594     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1595     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
1596     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
1597
1598     delete []redisStrVec;
1599 }
1600
1601 TEST(exstring, deliepub_command_same_string_reply)
1602 {
1603     RedisModuleCtx ctx;
1604     //RedisModuleString str;
1605     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1606
1607     redisStrVec[0] = (RedisModuleString *)1;
1608     redisStrVec[1] = (RedisModuleString *)1;
1609     redisStrVec[2] = (RedisModuleString *)1;
1610     redisStrVec[3] = (RedisModuleString *)1;
1611     redisStrVec[4] = (RedisModuleString *)1;
1612
1613     mock().setData("RedisModule_OpenKey_have", 1);
1614     mock().setData("RedisModule_KeyType_str", 1);
1615     mock().setData("RedisModule_String_same", 1);
1616     mock().setData("RedisModule_CallReplyType_str", 1);
1617     mock().setData("RedisModule_CallReplyInteger", 1);
1618     mock().expectOneCall("RedisModule_CloseKey");
1619     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec, 5);
1620     CHECK_EQUAL(ret, REDISMODULE_OK);
1621     mock().checkExpectations();
1622     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1623     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1624     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1625     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1626     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1627     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1628
1629     delete []redisStrVec;
1630 }
1631
1632 TEST(exstring, delnepub_command_same_string_reply)
1633 {
1634     RedisModuleCtx ctx;
1635     //RedisModuleString str;
1636     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1637
1638     redisStrVec[0] = (RedisModuleString *)1;
1639     redisStrVec[1] = (RedisModuleString *)1;
1640     redisStrVec[2] = (RedisModuleString *)1;
1641     redisStrVec[3] = (RedisModuleString *)1;
1642     redisStrVec[4] = (RedisModuleString *)1;
1643
1644     mock().setData("RedisModule_OpenKey_have", 1);
1645     mock().setData("RedisModule_KeyType_str", 1);
1646     mock().setData("RedisModule_String_same", 1);
1647     mock().setData("RedisModule_CallReplyType_str", 1);
1648     mock().expectOneCall("RedisModule_CloseKey");
1649     int ret = DelNEPub_RedisCommand(&ctx, redisStrVec, 5);
1650     CHECK_EQUAL(ret, REDISMODULE_OK);
1651     mock().checkExpectations();
1652     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1653     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1654     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1655     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1656     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1657     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1658
1659     delete []redisStrVec;
1660 }
1661
1662 TEST(exstring, delnepub_command_nosame_string_reply)
1663 {
1664     RedisModuleCtx ctx;
1665     //RedisModuleString str;
1666     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1667
1668     redisStrVec[0] = (RedisModuleString *)1;
1669     redisStrVec[1] = (RedisModuleString *)1;
1670     redisStrVec[2] = (RedisModuleString *)1;
1671     redisStrVec[3] = (RedisModuleString *)1;
1672     redisStrVec[4] = (RedisModuleString *)1;
1673
1674     mock().setData("RedisModule_OpenKey_have", 1);
1675     mock().setData("RedisModule_KeyType_str", 1);
1676     mock().setData("RedisModule_String_nosame", 1);
1677     mock().setData("RedisModule_CallReplyType_str", 1);
1678     mock().setData("RedisModule_CallReplyInteger", 1);
1679     mock().expectOneCall("RedisModule_CloseKey");
1680     int ret = DelNEPub_RedisCommand(&ctx, redisStrVec, 5);
1681     CHECK_EQUAL(ret, REDISMODULE_OK);
1682     mock().checkExpectations();
1683     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1684     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1685     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1686     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1687     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1688     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1689
1690     delete []redisStrVec;
1691 }