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, setxxpub)
 467 {
 468     RedisModuleCtx ctx;
 469     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 470
 471     redisStrVec[0] = (RedisModuleString *)1;
 472     redisStrVec[1] = (RedisModuleString *)1;
 473     redisStrVec[2] = (RedisModuleString *)1;
 474     redisStrVec[3] = (RedisModuleString *)1;
 475     redisStrVec[4] = (RedisModuleString *)1;
 476
 477     mock().setData("RedisModule_OpenKey_have", 1);
 478     mock().setData("RedisModule_KeyType_str", 1);
 479     mock().setData("RedisModule_String_same", 1);
 480     mock().setData("RedisModule_CallReplyType_null", 1);
 481
 482     mock().expectOneCall("RedisModule_CloseKey");
 483     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec,  5);
 484     CHECK_EQUAL(ret, REDISMODULE_OK);
 485     mock().checkExpectations();
 486     delete []redisStrVec;
 487 }
 488
 489 TEST(exstring, setnxpub)
 490 {
 491     RedisModuleCtx ctx;
 492     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 493
 494     redisStrVec[0] = (RedisModuleString *)1;
 495     redisStrVec[1] = (RedisModuleString *)1;
 496     redisStrVec[2] = (RedisModuleString *)1;
 497     redisStrVec[3] = (RedisModuleString *)1;
 498     redisStrVec[4] = (RedisModuleString *)1;
 499
 500     mock().setData("RedisModule_OpenKey_have", 1);
 501     mock().setData("RedisModule_KeyType_str", 1);
 502     mock().setData("RedisModule_String_same", 1);
 503     mock().setData("RedisModule_CallReplyType_null", 1);
 504
 505     mock().expectOneCall("RedisModule_CloseKey");
 506     int ret = SetNXPub_RedisCommand(&ctx, redisStrVec,  5);
 507     CHECK_EQUAL(ret, REDISMODULE_OK);
 508     mock().checkExpectations();
 509     delete []redisStrVec;
 510 }
 511
 512 TEST(exstring, setiepub)
 513 {
 514     RedisModuleCtx ctx;
 515     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 516
 517     redisStrVec[0] = (RedisModuleString *)1;
 518     redisStrVec[1] = (RedisModuleString *)1;
 519     redisStrVec[2] = (RedisModuleString *)1;
 520     redisStrVec[3] = (RedisModuleString *)1;
 521     redisStrVec[4] = (RedisModuleString *)1;
 522     redisStrVec[5] = (RedisModuleString *)1;
 523
 524     mock().setData("RedisModule_OpenKey_have", 1);
 525     mock().setData("RedisModule_KeyType_str", 1);
 526     mock().setData("RedisModule_String_same", 1);
 527     mock().setData("RedisModule_CallReplyType_null", 1);
 528
 529     mock().expectOneCall("RedisModule_CloseKey");
 530     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec,  6);
 531     CHECK_EQUAL(ret, REDISMODULE_OK);
 532     mock().checkExpectations();
 533     delete []redisStrVec;
 534 }
 535
 536 TEST(exstring, setnepub)
 537 {
 538     RedisModuleCtx ctx;
 539     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 540
 541     redisStrVec[0] = (RedisModuleString *)1;
 542     redisStrVec[1] = (RedisModuleString *)1;
 543     redisStrVec[2] = (RedisModuleString *)1;
 544     redisStrVec[3] = (RedisModuleString *)1;
 545     redisStrVec[4] = (RedisModuleString *)1;
 546     redisStrVec[5] = (RedisModuleString *)1;
 547
 548     mock().setData("RedisModule_OpenKey_have", 1);
 549     mock().setData("RedisModule_KeyType_str", 1);
 550     mock().setData("RedisModule_String_same", 1);
 551     mock().setData("RedisModule_CallReplyType_null", 1);
 552
 553     mock().expectOneCall("RedisModule_CloseKey");
 554     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec,  6);
 555     CHECK_EQUAL(ret, REDISMODULE_OK);
 556     mock().checkExpectations();
 557     delete []redisStrVec;
 558 }
 559
 560 TEST(exstring, setpub_command_parameter_number_incorrect)
 561 {
 562     RedisModuleCtx ctx;
 563     int ret = 0;
 564
 565     ret = SetPub_RedisCommand(&ctx, 0, 2);
 566     CHECK_EQUAL(ret, REDISMODULE_ERR);
 567
 568     ret = 0;
 569     ret = SetPub_RedisCommand(&ctx, 0, 8);
 570     CHECK_EQUAL(ret, REDISMODULE_ERR);
 571
 572     ret = 0;
 573     ret = SetXXPub_RedisCommand(&ctx, 0, 3);
 574     CHECK_EQUAL(ret, REDISMODULE_ERR);
 575
 576     ret = 0;
 577     ret = SetXXPub_RedisCommand(&ctx, 0, 6);
 578     CHECK_EQUAL(ret, REDISMODULE_ERR);
 579
 580     ret = 0;
 581     ret = SetNXPub_RedisCommand(&ctx, 0, 3);
 582     CHECK_EQUAL(ret, REDISMODULE_ERR);
 583
 584     ret = 0;
 585     ret = SetNXPub_RedisCommand(&ctx, 0, 6);
 586     CHECK_EQUAL(ret, REDISMODULE_ERR);
 587
 588     ret = 0;
 589     ret = SetIEPub_RedisCommand(&ctx, 0, 4);
 590     CHECK_EQUAL(ret, REDISMODULE_ERR);
 591
 592     ret = 0;
 593     ret = SetIEPub_RedisCommand(&ctx, 0, 9);
 594     CHECK_EQUAL(ret, REDISMODULE_ERR);
 595
 596     ret = 0;
 597     ret = SetNEPub_RedisCommand(&ctx, 0, 4);
 598     CHECK_EQUAL(ret, REDISMODULE_ERR);
 599
 600     ret = 0;
 601     ret = SetNEPub_RedisCommand(&ctx, 0, 9);
 602     CHECK_EQUAL(ret, REDISMODULE_ERR);
 603 }
 604
 605 TEST(exstring, setpub_command_no_key_replynull)
 606 {
 607     RedisModuleCtx ctx;
 608     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 609
 610     redisStrVec[0] = (RedisModuleString *)0;
 611     redisStrVec[1] = (RedisModuleString *)1;
 612     redisStrVec[2] = (RedisModuleString *)2;
 613     redisStrVec[3] = (RedisModuleString *)3;
 614     redisStrVec[4] = (RedisModuleString *)4;
 615
 616     mock().setData("RedisModule_KeyType_empty", 1);
 617     mock().setData("RedisModule_CallReplyType_null", 1);
 618
 619     int ret = SetPub_RedisCommand(&ctx, redisStrVec, 5);
 620     CHECK_EQUAL(ret, REDISMODULE_OK);
 621     mock().checkExpectations();
 622     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 623     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 624     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 625     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
 626
 627     delete []redisStrVec;
 628
 629 }
 630
 631 TEST(exstring, setpub_command_no_key_replystr)
 632 {
 633     RedisModuleCtx ctx;
 634     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 635
 636     redisStrVec[0] = (RedisModuleString *)0;
 637     redisStrVec[1] = (RedisModuleString *)1;
 638     redisStrVec[2] = (RedisModuleString *)2;
 639     redisStrVec[3] = (RedisModuleString *)3;
 640     redisStrVec[4] = (RedisModuleString *)4;
 641
 642     mock().setData("RedisModule_KeyType_empty", 1);
 643     mock().setData("RedisModule_CallReplyType_str", 1);
 644
 645     int ret = SetPub_RedisCommand(&ctx, redisStrVec, 5);
 646     CHECK_EQUAL(ret, REDISMODULE_OK);
 647     mock().checkExpectations();
 648     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 649     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 650     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 651     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 652
 653     delete []redisStrVec;
 654
 655 }
 656
 657 TEST(exstring, setxxpub_command_has_no_key)
 658 {
 659     RedisModuleCtx ctx;
 660     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 661
 662     redisStrVec[0] = (RedisModuleString *)0;
 663     redisStrVec[1] = (RedisModuleString *)1;
 664     redisStrVec[2] = (RedisModuleString *)2;
 665     redisStrVec[3] = (RedisModuleString *)3;
 666     redisStrVec[4] = (RedisModuleString *)4;
 667
 668     mock().setData("RedisModule_KeyType_empty", 1);
 669     mock().setData("RedisModule_CallReplyType_null", 1);
 670
 671     mock().expectOneCall("RedisModule_CloseKey");
 672     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec, 5);
 673
 674     CHECK_EQUAL(ret, REDISMODULE_OK);
 675     mock().checkExpectations();
 676     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 677     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 678     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 679     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 680     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 681
 682     delete []redisStrVec;
 683
 684 }
 685
 686 TEST(exstring, setxxpub_command_parameter_has_key_set)
 687 {
 688     RedisModuleCtx ctx;
 689     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 690
 691     redisStrVec[0] = (RedisModuleString *)0;
 692     redisStrVec[1] = (RedisModuleString *)1;
 693     redisStrVec[2] = (RedisModuleString *)2;
 694     redisStrVec[3] = (RedisModuleString *)3;
 695     redisStrVec[4] = (RedisModuleString *)4;
 696
 697     mock().setData("RedisModule_KeyType_set", 1);
 698
 699     mock().expectOneCall("RedisModule_CloseKey");
 700     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec, 5);
 701
 702     CHECK_EQUAL(ret, REDISMODULE_OK);
 703     mock().checkExpectations();
 704     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
 705     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 706     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 707     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 708     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 709
 710     delete []redisStrVec;
 711
 712 }
 713
 714 TEST(exstring, setxxpub_command_has_key_string)
 715 {
 716     RedisModuleCtx ctx;
 717     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 718
 719     redisStrVec[0] = (RedisModuleString *)0;
 720     redisStrVec[1] = (RedisModuleString *)1;
 721     redisStrVec[2] = (RedisModuleString *)2;
 722     redisStrVec[3] = (RedisModuleString *)3;
 723     redisStrVec[4] = (RedisModuleString *)4;
 724
 725     mock().setData("RedisModule_KeyType_str", 1);
 726     mock().setData("RedisModule_CallReplyType_str", 1);
 727
 728     mock().expectOneCall("RedisModule_CloseKey");
 729     int ret = SetXXPub_RedisCommand(&ctx, redisStrVec, 5);
 730
 731     CHECK_EQUAL(ret, REDISMODULE_OK);
 732     mock().checkExpectations();
 733     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
 734     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 735     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 736     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 737     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 738
 739     delete []redisStrVec;
 740
 741 }
 742
 743
 744 TEST(exstring, setnxpub_command_has_key_string)
 745 {
 746     RedisModuleCtx ctx;
 747     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 748
 749     redisStrVec[0] = (RedisModuleString *)0;
 750     redisStrVec[1] = (RedisModuleString *)1;
 751     redisStrVec[2] = (RedisModuleString *)2;
 752     redisStrVec[3] = (RedisModuleString *)3;
 753     redisStrVec[4] = (RedisModuleString *)4;
 754
 755     mock().setData("RedisModule_KeyType_str", 1);
 756     mock().setData("RedisModule_CallReplyType_null", 1);
 757
 758     mock().expectOneCall("RedisModule_CloseKey");
 759     int ret = SetNXPub_RedisCommand(&ctx, redisStrVec, 5);
 760
 761     CHECK_EQUAL(ret, REDISMODULE_OK);
 762     mock().checkExpectations();
 763     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 764     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 765     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 766     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 767     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 768
 769     delete []redisStrVec;
 770
 771 }
 772
 773 TEST(exstring, setnxpub_command_has_no_key)
 774 {
 775     RedisModuleCtx ctx;
 776     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
 777
 778     redisStrVec[0] = (RedisModuleString *)0;
 779     redisStrVec[1] = (RedisModuleString *)1;
 780     redisStrVec[2] = (RedisModuleString *)2;
 781     redisStrVec[3] = (RedisModuleString *)3;
 782     redisStrVec[4] = (RedisModuleString *)4;
 783
 784     mock().setData("RedisModule_KeyType_empty", 1);
 785     mock().setData("RedisModule_CallReplyType_str", 1);
 786
 787     mock().expectOneCall("RedisModule_CloseKey");
 788     int ret = SetNXPub_RedisCommand(&ctx, redisStrVec, 5);
 789
 790     CHECK_EQUAL(ret, REDISMODULE_OK);
 791     mock().checkExpectations();
 792     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
 793     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 794     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 795     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 796     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 797
 798     delete []redisStrVec;
 799
 800 }
 801
 802
 803
 804 TEST(exstring, setiepub_command_has_no_key)
 805 {
 806     RedisModuleCtx ctx;
 807     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 808
 809     redisStrVec[0] = (RedisModuleString *)0;
 810     redisStrVec[1] = (RedisModuleString *)1;
 811     redisStrVec[2] = (RedisModuleString *)2;
 812     redisStrVec[3] = (RedisModuleString *)3;
 813     redisStrVec[4] = (RedisModuleString *)4;
 814     redisStrVec[5] = (RedisModuleString *)5;
 815
 816     mock().setData("RedisModule_KeyType_empty", 1);
 817     mock().setData("RedisModule_CallReplyType_str", 1);
 818
 819     mock().expectOneCall("RedisModule_CloseKey");
 820     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
 821
 822     CHECK_EQUAL(ret, REDISMODULE_OK);
 823     mock().checkExpectations();
 824     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 825     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
 826     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 827     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 828     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
 829
 830     delete []redisStrVec;
 831
 832 }
 833
 834
 835 TEST(exstring, setiepub_command_key_string_nosame)
 836 {
 837     RedisModuleCtx ctx;
 838     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 839
 840     redisStrVec[0] = (RedisModuleString *)0;
 841     redisStrVec[1] = (RedisModuleString *)1;
 842     redisStrVec[2] = (RedisModuleString *)2;
 843     redisStrVec[3] = (RedisModuleString *)3;
 844     redisStrVec[4] = (RedisModuleString *)4;
 845     redisStrVec[5] = (RedisModuleString *)5;
 846
 847     mock().setData("RedisModule_KeyType_str", 1);
 848     mock().setData("RedisModule_CallReplyType_str", 1);
 849     mock().setData("RedisModule_String_nosame", 1);
 850
 851     mock().expectOneCall("RedisModule_CloseKey");
 852     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
 853
 854     CHECK_EQUAL(ret, REDISMODULE_OK);
 855     mock().checkExpectations();
 856     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 857     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 858     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 859     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 860     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
 861
 862     delete []redisStrVec;
 863
 864 }
 865
 866 TEST(exstring, setiepub_command_key_same_string_replynull)
 867 {
 868     RedisModuleCtx ctx;
 869     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 870
 871     redisStrVec[0] = (RedisModuleString *)0;
 872     redisStrVec[1] = (RedisModuleString *)1;
 873     redisStrVec[2] = (RedisModuleString *)2;
 874     redisStrVec[3] = (RedisModuleString *)3;
 875     redisStrVec[4] = (RedisModuleString *)4;
 876     redisStrVec[5] = (RedisModuleString *)5;
 877
 878     mock().setData("RedisModule_KeyType_str", 1);
 879     mock().setData("RedisModule_String_same", 1);
 880     mock().setData("RedisModule_CallReplyType_null", 1);
 881
 882     mock().expectOneCall("RedisModule_CloseKey");
 883     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
 884
 885     CHECK_EQUAL(ret, REDISMODULE_OK);
 886     mock().checkExpectations();
 887     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 888     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 889     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 890     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 891     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
 892
 893     delete []redisStrVec;
 894
 895 }
 896
 897 TEST(exstring, setiepub_command_key_same_string_reply)
 898 {
 899     RedisModuleCtx ctx;
 900     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 901
 902     redisStrVec[0] = (RedisModuleString *)0;
 903     redisStrVec[1] = (RedisModuleString *)1;
 904     redisStrVec[2] = (RedisModuleString *)2;
 905     redisStrVec[3] = (RedisModuleString *)3;
 906     redisStrVec[4] = (RedisModuleString *)4;
 907     redisStrVec[5] = (RedisModuleString *)5;
 908
 909     mock().setData("RedisModule_KeyType_str", 1);
 910     mock().setData("RedisModule_String_same", 1);
 911     mock().setData("RedisModule_CallReplyType_str", 1);
 912
 913     mock().expectOneCall("RedisModule_CloseKey");
 914     int ret = SetIEPub_RedisCommand(&ctx, redisStrVec, 6);
 915
 916     CHECK_EQUAL(ret, REDISMODULE_OK);
 917     mock().checkExpectations();
 918     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 919     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 920     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 921     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
 922     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
 923
 924     delete []redisStrVec;
 925
 926 }
 927
 928 TEST(exstring, setnepub_command_has_no_key)
 929 {
 930     RedisModuleCtx ctx;
 931     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 932
 933     redisStrVec[0] = (RedisModuleString *)0;
 934     redisStrVec[1] = (RedisModuleString *)1;
 935     redisStrVec[2] = (RedisModuleString *)2;
 936     redisStrVec[3] = (RedisModuleString *)3;
 937     redisStrVec[4] = (RedisModuleString *)4;
 938     redisStrVec[5] = (RedisModuleString *)5;
 939
 940     mock().setData("RedisModule_KeyType_empty", 1);
 941     mock().setData("RedisModule_CallReplyType_str", 1);
 942     mock().setData("RedisModule_String_nosame", 1);
 943
 944     mock().expectOneCall("RedisModule_CloseKey");
 945     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec, 6);
 946
 947     CHECK_EQUAL(ret, REDISMODULE_OK);
 948     mock().checkExpectations();
 949     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 950     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
 951     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
 952     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
 953     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
 954
 955     delete []redisStrVec;
 956
 957 }
 958
 959 TEST(exstring, setnepub_command_key_string_same_reply)
 960 {
 961     RedisModuleCtx ctx;
 962     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 963
 964     redisStrVec[0] = (RedisModuleString *)0;
 965     redisStrVec[1] = (RedisModuleString *)1;
 966     redisStrVec[2] = (RedisModuleString *)2;
 967     redisStrVec[3] = (RedisModuleString *)3;
 968     redisStrVec[4] = (RedisModuleString *)4;
 969     redisStrVec[5] = (RedisModuleString *)5;
 970
 971     mock().setData("RedisModule_KeyType_str", 1);
 972     mock().setData("RedisModule_String_same", 1);
 973     mock().setData("RedisModule_CallReplyType_str", 1);
 974
 975     mock().expectOneCall("RedisModule_CloseKey");
 976     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec, 6);
 977
 978     CHECK_EQUAL(ret, REDISMODULE_OK);
 979     mock().checkExpectations();
 980     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
 981     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 0);
 982     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
 983     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
 984     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
 985
 986     delete []redisStrVec;
 987
 988 }
 989
 990
 991 TEST(exstring, setnepub_command_key_string_nosame_reply)
 992 {
 993     RedisModuleCtx ctx;
 994     RedisModuleString ** redisStrVec = new (RedisModuleString*[6]);
 995
 996     redisStrVec[0] = (RedisModuleString *)0;
 997     redisStrVec[1] = (RedisModuleString *)1;
 998     redisStrVec[2] = (RedisModuleString *)2;
 999     redisStrVec[3] = (RedisModuleString *)3;
1000     redisStrVec[4] = (RedisModuleString *)4;
1001     redisStrVec[5] = (RedisModuleString *)5;
1002
1003     mock().setData("RedisModule_KeyType_str", 1);
1004     mock().setData("RedisModule_CallReplyType_str", 1);
1005     mock().setData("RedisModule_String_nosame", 1);
1006
1007     mock().expectOneCall("RedisModule_CloseKey");
1008     int ret = SetNEPub_RedisCommand(&ctx, redisStrVec, 6);
1009
1010     CHECK_EQUAL(ret, REDISMODULE_OK);
1011     mock().checkExpectations();
1012     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1013     CHECK_EQUAL(mock().getData("MSET").getIntValue(), 1);
1014     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1015     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1016     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1017
1018     delete []redisStrVec;
1019
1020 }
1021
1022 TEST(exstring, delpub)
1023 {
1024     RedisModuleCtx ctx;
1025     RedisModuleString ** redisStrVec = new (RedisModuleString*[4]);
1026
1027     redisStrVec[0] = (RedisModuleString *)1;
1028     redisStrVec[1] = (RedisModuleString *)1;
1029     redisStrVec[2] = (RedisModuleString *)1;
1030     redisStrVec[3] = (RedisModuleString *)1;
1031
1032     mock().setData("RedisModule_OpenKey_have", 1);
1033     mock().setData("RedisModule_KeyType_str", 1);
1034     mock().setData("RedisModule_String_same", 1);
1035     mock().setData("RedisModule_CallReplyType_null", 1);
1036
1037     int ret = DelPub_RedisCommand(&ctx, redisStrVec,  4);
1038     CHECK_EQUAL(ret, REDISMODULE_OK);
1039
1040     delete []redisStrVec;
1041 }
1042
1043 TEST(exstring, deliepub)
1044 {
1045     RedisModuleCtx ctx;
1046     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1047
1048     redisStrVec[0] = (RedisModuleString *)1;
1049     redisStrVec[1] = (RedisModuleString *)1;
1050     redisStrVec[2] = (RedisModuleString *)1;
1051     redisStrVec[3] = (RedisModuleString *)1;
1052     redisStrVec[4] = (RedisModuleString *)1;
1053
1054     mock().setData("RedisModule_OpenKey_have", 1);
1055     mock().setData("RedisModule_KeyType_str", 1);
1056     mock().setData("RedisModule_String_same", 1);
1057     mock().setData("RedisModule_CallReplyType_null", 1);
1058
1059     mock().expectOneCall("RedisModule_CloseKey");
1060     int ret = DelIEPub_RedisCommand(&ctx, redisStrVec,  5);
1061     CHECK_EQUAL(ret, REDISMODULE_OK);
1062     mock().checkExpectations();
1063     delete []redisStrVec;
1064 }
1065
1066 TEST(exstring, delnepub)
1067 {
1068     RedisModuleCtx ctx;
1069     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1070
1071     redisStrVec[0] = (RedisModuleString *)1;
1072     redisStrVec[1] = (RedisModuleString *)1;
1073     redisStrVec[2] = (RedisModuleString *)1;
1074     redisStrVec[3] = (RedisModuleString *)1;
1075     redisStrVec[4] = (RedisModuleString *)1;
1076
1077     mock().setData("RedisModule_OpenKey_have", 1);
1078     mock().setData("RedisModule_KeyType_str", 1);
1079     mock().setData("RedisModule_String_same", 1);
1080     mock().setData("RedisModule_CallReplyType_null", 1);
1081
1082     mock().expectOneCall("RedisModule_CloseKey");
1083     int ret = DelNEPub_RedisCommand(&ctx, redisStrVec,  5);
1084     CHECK_EQUAL(ret, REDISMODULE_OK);
1085     mock().checkExpectations();
1086     delete []redisStrVec;
1087 }
1088
1089 TEST(exstring, delpub_command_parameter_number_incorrect)
1090 {
1091     RedisModuleCtx ctx;
1092     int ret = 0;
1093     ret = delPubStringGenericCommand(&ctx, 0, 2, OBJ_OP_NO);
1094     CHECK_EQUAL(ret, REDISMODULE_ERR);
1095
1096     ret = 0;
1097     ret = delPubStringGenericCommand(&ctx, 0, 4, OBJ_OP_IE);
1098     CHECK_EQUAL(ret, REDISMODULE_ERR);
1099
1100     ret = 0;
1101     ret = delPubStringGenericCommand(&ctx, 0, 8, OBJ_OP_NE);
1102     CHECK_EQUAL(ret, REDISMODULE_ERR);
1103 }
1104
1105 TEST(exstring, delpub_command_reply_null)
1106 {
1107     RedisModuleCtx ctx;
1108     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1109
1110     redisStrVec[0] = (RedisModuleString *)1;
1111     redisStrVec[1] = (RedisModuleString *)1;
1112     redisStrVec[2] = (RedisModuleString *)1;
1113     redisStrVec[3] = (RedisModuleString *)1;
1114     redisStrVec[4] = (RedisModuleString *)1;
1115     mock().setData("RedisModule_CallReplyInteger", 0);
1116     mock().setData("RedisModule_CallReplyType_inter", 1);
1117     mock().setData("RedisModule_Call_Return_Null", 0);
1118
1119     int ret = delPubStringGenericCommand(&ctx, redisStrVec, 5, OBJ_OP_NO);
1120     CHECK_EQUAL(ret, 0);
1121     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1122     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1123     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1124     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 0);
1125     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1126     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
1127     delete []redisStrVec;
1128
1129 }
1130
1131 TEST(exstring, delpub_command_reply_error)
1132 {
1133     RedisModuleCtx ctx;
1134     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1135
1136     redisStrVec[0] = (RedisModuleString *)1;
1137     redisStrVec[1] = (RedisModuleString *)1;
1138     redisStrVec[2] = (RedisModuleString *)1;
1139     redisStrVec[3] = (RedisModuleString *)1;
1140     redisStrVec[4] = (RedisModuleString *)1;
1141     mock().setData("RedisModule_CallReplyInteger", 0);
1142     mock().setData("RedisModule_CallReplyType_err", 1);
1143
1144     int ret = delPubStringGenericCommand(&ctx, redisStrVec, 5, OBJ_OP_NO);
1145     CHECK_EQUAL(ret, REDISMODULE_ERR);
1146     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1147     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1148     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1149     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1150     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1151     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1152     delete []redisStrVec;
1153
1154 }
1155
1156 TEST(exstring, delpub_command_has_no_key)
1157 {
1158     RedisModuleCtx ctx;
1159     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1160
1161     redisStrVec[0] = (RedisModuleString *)1;
1162     redisStrVec[1] = (RedisModuleString *)1;
1163     redisStrVec[2] = (RedisModuleString *)1;
1164     redisStrVec[3] = (RedisModuleString *)1;
1165     redisStrVec[4] = (RedisModuleString *)1;
1166     mock().setData("RedisModule_CallReplyInteger", 0);
1167     mock().setData("RedisModule_CallReplyType_inter", 1);
1168
1169     int ret = delPubStringGenericCommand(&ctx, redisStrVec, 5, OBJ_OP_NO);
1170     CHECK_EQUAL(ret, 0);
1171     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1172     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1173     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1174     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1175     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1176     delete []redisStrVec;
1177
1178 }
1179
1180 TEST(exstring, deliepub_command_has_no_key)
1181 {
1182     RedisModuleCtx ctx;
1183     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1184
1185     redisStrVec[0] = (RedisModuleString *)1;
1186     redisStrVec[1] = (RedisModuleString *)1;
1187     redisStrVec[2] = (RedisModuleString *)1;
1188     redisStrVec[3] = (RedisModuleString *)1;
1189     redisStrVec[4] = (RedisModuleString *)1;
1190     mock().setData("RedisModule_KeyType_empty", 1);
1191
1192     mock().expectOneCall("RedisModule_CloseKey");
1193     int ret = delPubStringGenericCommand(&ctx, redisStrVec, 5, OBJ_OP_IE);
1194     CHECK_EQUAL(ret, 0);
1195     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1196     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1197     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1198     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1199     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1200     delete []redisStrVec;
1201
1202 }
1203
1204 TEST(exstring, deliepub_command_has_key_set)
1205 {
1206     RedisModuleCtx ctx;
1207     //RedisModuleString str;
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
1216     mock().setData("RedisModule_OpenKey_have", 1);
1217     mock().setData("RedisModule_KeyType_set", 1);
1218     mock().expectOneCall("RedisModule_CloseKey");
1219     int ret = delPubStringGenericCommand(&ctx, redisStrVec, 5, OBJ_OP_IE);
1220     CHECK_EQUAL(ret, REDISMODULE_OK);
1221     mock().checkExpectations();
1222     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 1);
1223     CHECK_EQUAL(mock().getData("GET").getIntValue(), 0);
1224     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1225     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1226     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 0);
1227
1228     delete []redisStrVec;
1229 }
1230
1231 TEST(exstring, deliepub_command_key_string_nosame)
1232 {
1233     RedisModuleCtx ctx;
1234     //RedisModuleString str;
1235     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1236
1237     redisStrVec[0] = (RedisModuleString *)1;
1238     redisStrVec[1] = (RedisModuleString *)1;
1239     redisStrVec[2] = (RedisModuleString *)1;
1240     redisStrVec[3] = (RedisModuleString *)1;
1241     redisStrVec[4] = (RedisModuleString *)1;
1242
1243     mock().setData("RedisModule_OpenKey_have", 1);
1244     mock().setData("RedisModule_KeyType_str", 1);
1245     mock().setData("RedisModule_String_nosame", 1);
1246     mock().expectOneCall("RedisModule_CloseKey");
1247     int ret = delPubStringGenericCommand(&ctx, redisStrVec, 5, OBJ_OP_IE);
1248     CHECK_EQUAL(ret, REDISMODULE_OK);
1249     mock().checkExpectations();
1250     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1251     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1252     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1253     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1254     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1255     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1256
1257     delete []redisStrVec;
1258 }
1259
1260 TEST(exstring, deliepub_command_same_string_replynull)
1261 {
1262     RedisModuleCtx ctx;
1263     //RedisModuleString str;
1264     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1265
1266     redisStrVec[0] = (RedisModuleString *)1;
1267     redisStrVec[1] = (RedisModuleString *)1;
1268     redisStrVec[2] = (RedisModuleString *)1;
1269     redisStrVec[3] = (RedisModuleString *)1;
1270     redisStrVec[4] = (RedisModuleString *)1;
1271
1272     mock().setData("RedisModule_OpenKey_have", 1);
1273     mock().setData("RedisModule_KeyType_str", 1);
1274     mock().setData("RedisModule_String_same", 1);
1275     mock().setData("RedisModule_CallReplyType_null", 1);
1276     mock().expectOneCall("RedisModule_CloseKey");
1277     int ret = delPubStringGenericCommand(&ctx, redisStrVec, 5, OBJ_OP_IE);
1278     CHECK_EQUAL(ret, REDISMODULE_OK);
1279     mock().checkExpectations();
1280     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1281     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1282     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1283     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1284     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithNull").getIntValue(), 1);
1285     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
1286
1287     delete []redisStrVec;
1288 }
1289
1290 TEST(exstring, deliepub_command_same_string_reply)
1291 {
1292     RedisModuleCtx ctx;
1293     //RedisModuleString str;
1294     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1295
1296     redisStrVec[0] = (RedisModuleString *)1;
1297     redisStrVec[1] = (RedisModuleString *)1;
1298     redisStrVec[2] = (RedisModuleString *)1;
1299     redisStrVec[3] = (RedisModuleString *)1;
1300     redisStrVec[4] = (RedisModuleString *)1;
1301
1302     mock().setData("RedisModule_OpenKey_have", 1);
1303     mock().setData("RedisModule_KeyType_str", 1);
1304     mock().setData("RedisModule_String_same", 1);
1305     mock().setData("RedisModule_CallReplyType_str", 1);
1306     mock().setData("RedisModule_CallReplyInteger", 1);
1307     mock().expectOneCall("RedisModule_CloseKey");
1308     int ret = delPubStringGenericCommand(&ctx, redisStrVec, 5, OBJ_OP_IE);
1309     CHECK_EQUAL(ret, REDISMODULE_OK);
1310     mock().checkExpectations();
1311     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1312     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1313     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1314     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1315     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1316     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1317
1318     delete []redisStrVec;
1319 }
1320
1321 TEST(exstring, delnepub_command_same_string_reply)
1322 {
1323     RedisModuleCtx ctx;
1324     //RedisModuleString str;
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
1333     mock().setData("RedisModule_OpenKey_have", 1);
1334     mock().setData("RedisModule_KeyType_str", 1);
1335     mock().setData("RedisModule_String_same", 1);
1336     mock().setData("RedisModule_CallReplyType_str", 1);
1337     mock().expectOneCall("RedisModule_CloseKey");
1338     int ret = delPubStringGenericCommand(&ctx, redisStrVec, 5, OBJ_OP_NE);
1339     CHECK_EQUAL(ret, REDISMODULE_OK);
1340     mock().checkExpectations();
1341     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1342     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1343     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 0);
1344     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 0);
1345     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1346     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1347
1348     delete []redisStrVec;
1349 }
1350
1351 TEST(exstring, delnepub_command_nosame_string_reply)
1352 {
1353     RedisModuleCtx ctx;
1354     //RedisModuleString str;
1355     RedisModuleString ** redisStrVec = new (RedisModuleString*[5]);
1356
1357     redisStrVec[0] = (RedisModuleString *)1;
1358     redisStrVec[1] = (RedisModuleString *)1;
1359     redisStrVec[2] = (RedisModuleString *)1;
1360     redisStrVec[3] = (RedisModuleString *)1;
1361     redisStrVec[4] = (RedisModuleString *)1;
1362
1363     mock().setData("RedisModule_OpenKey_have", 1);
1364     mock().setData("RedisModule_KeyType_str", 1);
1365     mock().setData("RedisModule_String_nosame", 1);
1366     mock().setData("RedisModule_CallReplyType_str", 1);
1367     mock().setData("RedisModule_CallReplyInteger", 1);
1368     mock().expectOneCall("RedisModule_CloseKey");
1369     int ret = delPubStringGenericCommand(&ctx, redisStrVec, 5, OBJ_OP_NE);
1370     CHECK_EQUAL(ret, REDISMODULE_OK);
1371     mock().checkExpectations();
1372     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithError").getIntValue(), 0);
1373     CHECK_EQUAL(mock().getData("GET").getIntValue(), 1);
1374     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1375     CHECK_EQUAL(mock().getData("PUBLISH").getIntValue(), 1);
1376     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1377     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 3);
1378
1379     delete []redisStrVec;
1380 }
1381
1382 TEST(exstring, nget_command_parameter_number_incorrect)
1383 {
1384     RedisModuleCtx ctx;
1385     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1386     redisStrVec[0] = (RedisModuleString *)1;
1387     redisStrVec[1] = (RedisModuleString *)1;
1388
1389     int ret = NGet_RedisCommand(&ctx, redisStrVec,  3);
1390     CHECK_EQUAL(ret, REDISMODULE_ERR);
1391
1392     delete []redisStrVec;
1393 }
1394
1395 TEST(exstring, nget_command_zero_item)
1396 {
1397     RedisModuleCtx ctx;
1398     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1399     redisStrVec[0] = (RedisModuleString *)1;
1400     redisStrVec[1] = (RedisModuleString *)1;
1401
1402     mock().setData("RedisModule_CallReplyLength", 0);
1403     int ret = NGet_RedisCommand(&ctx, redisStrVec,  2);
1404     CHECK_EQUAL(ret, REDISMODULE_OK);
1405     CHECK_EQUAL(mock().getData("KEYS").getIntValue(), 1);
1406     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1407     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1408
1409     delete []redisStrVec;
1410 }
1411
1412 TEST(exstring, nget_command_none_zero_items)
1413 {
1414     RedisModuleCtx ctx;
1415     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1416     redisStrVec[0] = (RedisModuleString *)1;
1417     redisStrVec[1] = (RedisModuleString *)1;
1418
1419     mock().setData("RedisModule_CallReplyLength", 3);
1420     int ret = NGet_RedisCommand(&ctx, redisStrVec,  2);
1421     CHECK_EQUAL(ret, REDISMODULE_OK);
1422     CHECK_EQUAL(mock().getData("KEYS").getIntValue(), 1);
1423     CHECK_EQUAL(mock().getData("MGET").getIntValue(), 1);
1424     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithArray").getIntValue(), 3*2);
1425     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithString").getIntValue(), 3*2);
1426     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
1427
1428     delete []redisStrVec;
1429 }
1430
1431 TEST(exstring, ndel_command_parameter_parameter_number_incorrect)
1432 {
1433     RedisModuleCtx ctx;
1434     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1435     redisStrVec[0] = (RedisModuleString *)1;
1436     redisStrVec[1] = (RedisModuleString *)1;
1437
1438     int ret = NDel_RedisCommand(&ctx, redisStrVec,  3);
1439     CHECK_EQUAL(ret, REDISMODULE_ERR);
1440
1441     delete []redisStrVec;
1442 }
1443
1444 TEST(exstring, ndel_command_zero_item)
1445 {
1446     RedisModuleCtx ctx;
1447     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1448     redisStrVec[0] = (RedisModuleString *)1;
1449     redisStrVec[1] = (RedisModuleString *)1;
1450
1451     mock().setData("RedisModule_CallReplyLength", 0);
1452     int ret = NDel_RedisCommand(&ctx, redisStrVec,  2);
1453     CHECK_EQUAL(ret, REDISMODULE_OK);
1454     CHECK_EQUAL(mock().getData("KEYS").getIntValue(), 1);
1455     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithLongLong").getIntValue(), 0);
1456     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 1);
1457
1458     delete []redisStrVec;
1459 }
1460
1461 TEST(exstring, ndel_command_none_zero_items)
1462 {
1463     RedisModuleCtx ctx;
1464     RedisModuleString ** redisStrVec = new (RedisModuleString*[2]);
1465     redisStrVec[0] = (RedisModuleString *)1;
1466     redisStrVec[1] = (RedisModuleString *)1;
1467
1468     mock().setData("RedisModule_CallReplyLength", 3);
1469     int ret = NDel_RedisCommand(&ctx, redisStrVec,  2);
1470     CHECK_EQUAL(ret, REDISMODULE_OK);
1471     CHECK_EQUAL(mock().getData("KEYS").getIntValue(), 1);
1472     CHECK_EQUAL(mock().getData("UNLINK").getIntValue(), 1);
1473     CHECK_EQUAL(mock().getData("RedisModule_ReplyWithCallReply").getIntValue(), 1);
1474     CHECK_EQUAL(mock().getData("RedisModule_FreeCallReply").getIntValue(), 2);
1475
1476     delete []redisStrVec;
1477 }