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