redismodule/tst/src/exstrings_test.cpp

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