void TestLoad(const char *testdata_path) { ++gTotalTests; nsMetricsConfig config; ASSERT_TRUE(config.Init()); nsCOMPtr<nsILocalFile> dataFile; NS_NewNativeLocalFile(nsDependentCString(testdata_path), PR_TRUE, getter_AddRefs(dataFile)); ASSERT_TRUE(dataFile); ASSERT_SUCCESS(dataFile->AppendNative( NS_LITERAL_CSTRING("test_config.xml"))); ASSERT_SUCCESS(config.Load(dataFile)); ASSERT_TRUE(config.IsEventEnabled(NS_LITERAL_STRING(NS_METRICS_NAMESPACE), NS_LITERAL_STRING("foo"))); ASSERT_TRUE(config.IsEventEnabled(NS_LITERAL_STRING(NS_METRICS_NAMESPACE), NS_LITERAL_STRING("bar"))); ASSERT_FALSE(config.IsEventEnabled(NS_LITERAL_STRING(NS_METRICS_NAMESPACE), NS_LITERAL_STRING("baz"))); ASSERT_TRUE(config.EventLimit() == 200); ASSERT_TRUE(config.UploadInterval() == 1000); ASSERT_TRUE(config.HasConfig()); ++gPassedTests; }
TEST(plankton, cycles) { CREATE_RUNTIME(); value_t i0 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species)); value_t k0 = new_integer(78); ASSERT_SUCCESS(set_instance_field(runtime, i0, k0, i0)); value_t d0 = transcode_plankton(runtime, NULL, NULL, i0); ASSERT_SAME(d0, get_instance_field(d0, k0)); value_t i1 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species)); value_t i2 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species)); value_t i3 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species)); value_t k1 = new_integer(79); ASSERT_SUCCESS(set_instance_field(runtime, i1, k0, i2)); ASSERT_SUCCESS(set_instance_field(runtime, i1, k1, i3)); ASSERT_SUCCESS(set_instance_field(runtime, i2, k1, i3)); ASSERT_SUCCESS(set_instance_field(runtime, i3, k0, i1)); value_t d1 = transcode_plankton(runtime, NULL, NULL, i1); value_t d2 = get_instance_field(d1, k0); value_t d3 = get_instance_field(d1, k1); ASSERT_NSAME(d1, d2); ASSERT_NSAME(d1, d3); ASSERT_SAME(d3, get_instance_field(d2, k1)); ASSERT_SAME(d1, get_instance_field(d3, k0)); DISPOSE_RUNTIME(); }
//TODO: add more tests static bool testAreDuplicateIngredients() { Ingredient ing1 = ingredientInitialize("99 little bugs in the code", MEATY, 1, 1, 1, NULL); Ingredient ing2 = ingredientInitialize("99 little bugs in the code", MEATY, 1, 1, 1, NULL); Ingredient ing3 = ingredientInitialize("Fix one, Patch it up", MEATY, 1, 1, 1, NULL); Ingredient ing4 = ingredientInitialize("127 little bugs in the code", MEATY, 1, 1, 1, NULL); Dish dish1 = dishCreate("Buggy Code", "Myself", 5); Dish dish2 = dishCreate("Laggy Code", "You", 5); bool isDuplicate; dishAddIngredient(dish1, ing1); dishAddIngredient(dish1, ing2); ASSERT_SUCCESS(dishAreDuplicateIngredients(dish1, &isDuplicate)); ASSERT_TRUE(isDuplicate); dishAddIngredient(dish2, ing3); dishAddIngredient(dish2, ing4); ASSERT_SUCCESS(dishAreDuplicateIngredients(dish2, &isDuplicate)); ASSERT_FALSE(isDuplicate); dishDestroy(dish1); dishDestroy(dish2); return true; }
// Encodes and decodes a plankton value and returns the result. static value_t transcode_plankton(runtime_t *runtime, value_mapping_t *resolver, value_mapping_t *access, value_t value) { // Encode and decode the value. value_t encoded = plankton_serialize(runtime, resolver, value); ASSERT_SUCCESS(encoded); value_t decoded = plankton_deserialize(runtime, access, encoded); ASSERT_SUCCESS(decoded); return decoded; }
static int check(const struct TEST_VECTOR *test) { unsigned char out[MAX_OUT_LEN]; struct BLOCK_MODE_STATE ctx; size_t total = 0, out_len; struct BLOCK_STATE blk; if (!prim_avail(test->cipher)) return 1; ASSERT_SUCCESS(block_init(&blk, test->key, test->key_len, test->cipher, 0)); ASSERT_SUCCESS(block_mode_init(&ctx, &blk, test->iv, test->iv_len, 1, BLOCK_MODE_ECB, test->use_params ? &test->params : 0)); block_mode_update(&ctx, &blk, test->in, test->in_len, out, &out_len); total += out_len; ASSERT_SUCCESS(block_mode_final(&ctx, &blk, out + total, &out_len)); total += out_len; ASSERT_EQ(total, test->out_len); ASSERT_BUF_EQ(out, test->out, test->out_len); total = 0; ASSERT_SUCCESS(block_mode_init(&ctx, &blk, test->iv, test->iv_len, 0, BLOCK_MODE_ECB, test->use_params ? &test->params : 0)); block_mode_update(&ctx, &blk, test->out, test->out_len, out, &out_len); total += out_len; ASSERT_SUCCESS(block_mode_final(&ctx, &blk, out + total, &out_len)); total += out_len; ASSERT_EQ(total, test->in_len); ASSERT_BUF_EQ(out, test->in, test->in_len); block_final(&blk); return 1; }
//TODO: add more tests static bool testHowMuchTasty() { Dish dish = dishCreate("Tasty", "Me of course", 1); ASSERT_SUCCESS(dishTaste(dish, true)); ASSERT_SUCCESS(dishTaste(dish, true)); ASSERT_SUCCESS(dishTaste(dish, false)); double tastiness; ASSERT_SUCCESS(dishHowMuchTasty(dish, &tastiness)); ASSERT_DOUBLE_EQUALS(tastiness, (double)2 / 3); dishDestroy(dish); return true; }
TEST(plankton, instance) { CREATE_RUNTIME(); value_t instance = new_heap_instance(runtime, ROOT(runtime, empty_instance_species)); check_plankton(runtime, instance); DEF_HEAP_STR(x, "x"); ASSERT_SUCCESS(try_set_instance_field(instance, x, new_integer(8))); DEF_HEAP_STR(y, "y"); ASSERT_SUCCESS(try_set_instance_field(instance, y, new_integer(13))); value_t decoded = check_plankton(runtime, instance); ASSERT_SUCCESS(decoded); ASSERT_VALEQ(new_integer(8), get_instance_field(decoded, x)); DISPOSE_RUNTIME(); }
PHP_METHOD(Rows, nextPageAsync) { cassandra_rows* self = NULL; cassandra_session* session = NULL; CassFuture* future = NULL; cassandra_future_rows* future_rows = NULL; if (zend_parse_parameters_none() == FAILURE) return; self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC); if (!(self->result && cass_result_has_more_pages(self->result))) { object_init_ex(return_value, cassandra_future_value_ce); return; } ASSERT_SUCCESS(cass_statement_set_paging_state(self->statement->statement, self->result)); session = (cassandra_session*) zend_object_store_get_object(self->session TSRMLS_CC); future = cass_session_execute(session->session, self->statement->statement); object_init_ex(return_value, cassandra_future_rows_ce); future_rows = (cassandra_future_rows*) zend_object_store_get_object(return_value TSRMLS_CC); Z_ADDREF_P(self->session); future_rows->session = self->session; future_rows->statement = php_cassandra_add_ref(self->statement); future_rows->future = future; }
TEST(syntax, emitting) { CREATE_RUNTIME(); value_t ast = new_heap_literal_ast(runtime, yes()); assembler_t assm; ASSERT_SUCCESS(assembler_init(&assm, runtime, nothing(), scope_get_bottom())); ASSERT_SUCCESS(emit_value(ast, &assm)); assembler_emit_return(&assm); value_t code = assembler_flush(&assm); ASSERT_SUCCESS(code); value_t result = run_code_block_until_condition(ambience, code); ASSERT_VALEQ(yes(), result); assembler_dispose(&assm); DISPOSE_RUNTIME(); }
void bulk_nhgm_consumer_worker() { std::string tableName = ASIC_STATE_TABLE; swss::DBConnector db(ASIC_DB, "localhost", 6379, 0); swss::ConsumerTable c(&db, tableName); swss::Select cs; swss::Selectable *selectcs; int tmpfd; int ret = 0; cs.addSelectable(&c); while ((ret = cs.select(&selectcs, &tmpfd)) == swss::Select::OBJECT) { swss::KeyOpFieldsValuesTuple kco; c.pop(kco); auto& key = kfvKey(kco); auto& op = kfvOp(kco); if (starts_with(key, "SAI_OBJECT_TYPE_SWITCH")) continue; if (op == "bulkcreate") { sai_status_t status = processBulkEvent((sai_common_api_t)SAI_COMMON_API_BULK_CREATE, kco); ASSERT_SUCCESS("Failed to processBulkEvent"); break; } } }
Semaphore::~Semaphore() { // TODO Auto-generated destructor stub int res = -1; res = sem_destroy(&m_Sem); ASSERT_SUCCESS(res); }
//TODO: add more tests static bool testAddIngredient() { Dish dish = dishCreate("Shanim Hasumot", "Shanim Bli Regesh", 2); Ingredient ing1 = ingredientInitialize("Shanim Mehatsad", MEATY, 1, 1, 1, NULL); Ingredient ing2 = ingredientInitialize("Menutak", MILKY, 1, 1, 1, NULL); Ingredient ing3 = ingredientInitialize("Male Be-Uvdot", PARVE, 1, 1, 1, NULL); ASSERT_NULL_ARGUMENT(dishAddIngredient(NULL, ing1)); ASSERT_SUCCESS(dishAddIngredient(dish, ing1)); ASSERT_KOSHER_VIOLATION(dishAddIngredient(dish, ing2)); ASSERT_SUCCESS(dishAddIngredient(dish, ing1)); ASSERT_FULL(dishAddIngredient(dish, ing3)); dishDestroy(dish); return true; }
void TestSave(const char *temp_data_path) { ++gTotalTests; static const char kFilename[] = "test-save.xml"; static const char kExpectedContents[] = "<response xmlns=\"http://www.mozilla.org/metrics\"><config>" "<collectors>" "<collector type=\"uielement\"/>" "</collectors>" "<limit events=\"300\"/>" "<upload interval=\"500\"/>" "</config></response>"; nsMetricsConfig config; ASSERT_TRUE(config.Init()); // The data file goes to the current directory config.SetEventEnabled(NS_LITERAL_STRING(NS_METRICS_NAMESPACE), NS_LITERAL_STRING("uielement"), PR_TRUE); config.SetUploadInterval(500); config.SetEventLimit(300); nsCOMPtr<nsILocalFile> outFile; NS_NewNativeLocalFile(nsDependentCString(temp_data_path), PR_TRUE, getter_AddRefs(outFile)); ASSERT_TRUE(outFile); ASSERT_SUCCESS(outFile->AppendNative(nsDependentCString(kFilename))); ASSERT_SUCCESS(config.Save(outFile)); ASSERT_TRUE(CheckFileContents(outFile, kExpectedContents)); // Now test with no collectors static const char kExpectedOutputNoEvents[] = "<response xmlns=\"http://www.mozilla.org/metrics\"><config>" "<collectors/>" "<limit events=\"300\"/>" "<upload interval=\"500\"/>" "</config></response>"; config.ClearEvents(); ASSERT_SUCCESS(config.Save(outFile)); ASSERT_TRUE(CheckFileContents(outFile, kExpectedOutputNoEvents)); ++gPassedTests; }
//TODO: add more tests static bool testGetName() { Dish dish = dishCreate("Boiled Student", "Stav Doolman", 2); char* name; ASSERT_SUCCESS(dishGetName(dish, &name)); ASSERT_STRING_EQUALS(name, "Boiled Student"); name[0] = 'B'; char* dupName; ASSERT_SUCCESS(dishGetName(dish, &dupName)); ASSERT_STRING_EQUALS(dupName, "Boiled Student"); free(name); free(dupName); dishDestroy(dish); return true; }
//TODO: add more tests static bool testSetName() { Dish dish = dishCreate("Sweet & Sour Dor", "Ofer Givoli", 2); ASSERT_SUCCESS(dishSetName(dish, "Just Dor")); char* name; dishGetName(dish, &name); ASSERT_STRING_EQUALS(name, "Just Dor"); free(name); char newName[] = "New Blabla"; ASSERT_SUCCESS(dishSetName(dish, newName)); newName[0] = 'M'; dishGetName(dish, &name); ASSERT_STRING_EQUALS(name, "New Blabla"); free(name); dishDestroy(dish); return true; }
//TODO: add more tests static bool testRemoveIngredient() { ASSERT_NULL_ARGUMENT(dishRemoveIngredient(NULL, -1)); Dish dish = dishCreate("Hasrot Kol Ereh", "Ha Keisar Shel Yapan", 2); Ingredient ing1 = ingredientInitialize("Ha Keisar Shel Yapan", MEATY, 1, 1, 1, NULL); ASSERT_INGREDIENT_NOT_FOUND(dishRemoveIngredient(dish, 4)); ASSERT_INGREDIENT_NOT_FOUND(dishRemoveIngredient(dish, -2)); dishAddIngredient(dish, ing1); dishAddIngredient(dish, ing1); ASSERT_SUCCESS(dishRemoveIngredient(dish, 0)); ASSERT_SUCCESS(dishRemoveIngredient(dish, 0)); ASSERT_INGREDIENT_NOT_FOUND(dishRemoveIngredient(dish, 0)); dishDestroy(dish); return true; }
//TODO: add more tests static bool testGetCook() { Dish dish = dishCreate("Rotten Shlomo", "Sarai Duek", 2); char* cook; ASSERT_SUCCESS(dishGetCook(dish, &cook)); ASSERT_STRING_EQUALS(cook, "Sarai Duek"); free(cook); dishDestroy(dish); return true; }
PHP_METHOD(Rows, nextPage) { zval* timeout = NULL; cassandra_session* session = NULL; CassFuture* future = NULL; const CassResult* result = NULL; cassandra_rows* rows = NULL; cassandra_rows* self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC); if (!(self->result && cass_result_has_more_pages(self->result))) return; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &timeout) == FAILURE) { return; } ASSERT_SUCCESS(cass_statement_set_paging_state(self->statement->statement, self->result)); session = (cassandra_session*) zend_object_store_get_object(self->session TSRMLS_CC); future = cass_session_execute(session->session, self->statement->statement); if (php_cassandra_future_wait_timed(future, timeout TSRMLS_CC) == FAILURE) { return; } if (php_cassandra_future_is_error(future TSRMLS_CC) == FAILURE) { return; } result = cass_future_get_result(future); if (!result) { zend_throw_exception_ex(cassandra_runtime_exception_ce, 0 TSRMLS_CC, "Future doesn't contain a result."); return; } object_init_ex(return_value, cassandra_rows_ce); rows = (cassandra_rows*) zend_object_store_get_object(return_value TSRMLS_CC); if (php_cassandra_get_result(result, &rows->rows TSRMLS_CC) == FAILURE) { cass_result_free(result); zval_dtor(return_value); return; } Z_ADDREF_P(self->session); rows->statement = php_cassandra_add_ref(self->statement); rows->session = self->session; rows->result = result; }
VOID BenchmarkThreadPool( PLW_THREAD_POOL pPool, PBENCHMARK_SETTINGS pSettings, PULONG64 pullDuration, PULONG64 pullBytesTransferred ) { PLW_TASK_GROUP pGroup = NULL; PSOCKET* ppSockets1 = NULL; PSOCKET* ppSockets2 = NULL; size_t i = 0; ULONG64 ullTotal = 0; LONG64 llStart = 0; LONG64 llEnd = 0; ULONG64 ullTime = 0; NTSTATUS status; gpPool = pPool; gpSettings = pSettings; status = LwRtlCreateTaskGroup(gpPool, &pGroup); ASSERT_SUCCESS(status); status = LW_RTL_ALLOCATE_ARRAY_AUTO(&ppSockets1, gpSettings->ulPairs); ASSERT_SUCCESS(status); status = LW_RTL_ALLOCATE_ARRAY_AUTO(&ppSockets2, gpSettings->ulPairs); ASSERT_SUCCESS(status); for (i = 0; i < gpSettings->ulPairs; i++) { NTSTATUS status = CreateSocketPair(pGroup, &ppSockets1[i], &ppSockets2[i]); ASSERT_SUCCESS(status); } status = TimeNow(&llStart); ASSERT_SUCCESS(status); LwRtlWakeTaskGroup(pGroup); LwRtlWaitTaskGroup(pGroup); status = TimeNow(&llEnd); ASSERT_SUCCESS(status); ullTime = (ULONG64) (llEnd - llStart); LwRtlFreeTaskGroup(&pGroup); for (i = 0; i < gpSettings->ulPairs; i++) { ullTotal += ppSockets1[i]->ullTotalTransferred; } *pullDuration = ullTime; *pullBytesTransferred = ullTotal; }
void test_enable_recording() { SWSS_LOG_ENTER(); sai_attribute_t attr; attr.id = SAI_REDIS_SWITCH_ATTR_RECORD; attr.value.booldata = true; sai_switch_api_t *sai_switch_api = NULL; sai_api_query(SAI_API_SWITCH, (void**)&sai_switch_api); sai_status_t status = sai_switch_api->set_switch_attribute(SAI_NULL_OBJECT_ID, &attr); ASSERT_SUCCESS("Failed to enable recording"); }
void test_sai_initialize() { SWSS_LOG_ENTER(); // NOTE: this is just testing whether test application will // link against libsairedis, this api requires running redis db // with enabled unix socket sai_status_t status = sai_api_initialize(0, (service_method_table_t*)&test_services); // Mock the SAI api test_next_hop_group_api.create_next_hop_group_member = test_create_next_hop_group_member; sai_metadata_sai_next_hop_group_api = &test_next_hop_group_api; created_next_hop_group_member.clear(); ASSERT_SUCCESS("Failed to initialize api"); }
//TODO: add more tests static bool testGetQuality() { Dish dish = dishCreate("En Yoter Pahad", "En Yoter Klum", 2); Ingredient ing1 = ingredientInitialize("Ani Ish Kash", PARVE, 2000, 1, 1, NULL); Ingredient ing2 = ingredientInitialize("Ani Etz Akum", PARVE, 0, 10, 1, NULL); dishAddIngredient(dish, ing1); dishAddIngredient(dish, ing2); double quality; ASSERT_SUCCESS(dishGetQuality(dish, &quality)); ASSERT_DOUBLE_EQUALS(quality, 5); dishDestroy(dish); return true; }
static int check(const struct TEST_VECTOR *test) { unsigned char out[MAX_OUT_LEN]; if (!prim_avail(test->hash)) return 1; ASSERT_SUCCESS(kdf_hkdf(test->hash, 0, test->key, test->key_len, test->salt, test->salt_len, test->info, test->info_len, out, test->out_len)); ASSERT_BUF_EQ(out, test->out, test->out_len); return 1; }
PHP_METHOD(Rows, nextPageAsync) { cassandra_rows* self = NULL; cassandra_session* session = NULL; CassFuture* future = NULL; cassandra_future_rows* future_rows = NULL; cassandra_future_value* future_value; if (zend_parse_parameters_none() == FAILURE) return; self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC); if (self->future_next_page) { RETURN_ZVAL(self->future_next_page, 1, 0); } if (self->next_page) { Z_ADDREF_P(self->next_page); object_init_ex(self->future_next_page, cassandra_future_value_ce); future_value = (cassandra_future_value*) zend_object_store_get_object(self->future_next_page TSRMLS_CC); future_value->value = self->next_page; RETURN_ZVAL(self->future_next_page, 1, 0); } if (self->result == NULL) { object_init_ex(return_value, cassandra_future_value_ce); return; } ASSERT_SUCCESS(cass_statement_set_paging_state((CassStatement*) self->statement->data, self->result)); session = (cassandra_session*) zend_object_store_get_object(self->session TSRMLS_CC); future = cass_session_execute(session->session, (CassStatement*) self->statement->data); object_init_ex(self->future_next_page, cassandra_future_rows_ce); future_rows = (cassandra_future_rows*) zend_object_store_get_object(self->future_next_page TSRMLS_CC); Z_ADDREF_P(self->session); future_rows->session = self->session; future_rows->statement = php_cassandra_add_ref(self->statement); future_rows->future = future; php_cassandra_rows_clear(self); RETURN_ZVAL(self->future_next_page, 1, 0); }
//TODO: add more tests static bool testIsBetter() { Dish dish1 = dishCreate("Reva Shaa", "Mehake Barehov", 2); Dish dish2 = dishCreate("Lahaver Harusi", "Hadash", 2); Ingredient ing1 = ingredientInitialize("Dor", MEATY, 0, 4, 20, NULL); Ingredient ing2 = ingredientInitialize("Cohen", MEATY, 0, 6, 30, NULL); dishAddIngredient(dish1, ing1); dishAddIngredient(dish2, ing2); bool isBetter; ASSERT_SUCCESS(dishIsBetter(dish2, dish1, 0.7, &isBetter)); ASSERT_TRUE(isBetter); dishDestroy(dish1); dishDestroy(dish2); return true; }
static int check(const struct TEST_VECTOR *test) { unsigned char out[MAX_OUT_LEN]; struct BLOCK_STATE state; ASSERT_SUCCESS(block_init(&state, test->key, test->key_len, BLOCK_AES, test->use_params ? &test->params : 0)); memcpy(out, test->in, test->in_len); block_forward(&state, out); ASSERT_BUF_EQ(out, test->out, test->out_len); block_inverse(&state, out); ASSERT_BUF_EQ(out, test->in, test->in_len); block_final(&state); return 1; }
void Semaphore::Wait() { int res = sem_wait(&m_Sem); ASSERT_SUCCESS(res); }
void Semaphore::Post() { int res = sem_post(&m_Sem); ASSERT_SUCCESS(res); }
Semaphore::Semaphore() { // TODO Auto-generated constructor stub int res = sem_init(&m_Sem, 0, 0); ASSERT_SUCCESS(res); }
PHP_METHOD(Rows, nextPage) { zval* timeout = NULL; cassandra_session* session = NULL; CassFuture* future = NULL; const CassResult* result = NULL; cassandra_rows* rows = NULL; cassandra_future_rows* future_rows = NULL; cassandra_rows* self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC); if (self->next_page) { RETURN_ZVAL(self->next_page, 1, 0); } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &timeout) == FAILURE) { return; } if (self->future_next_page) { if (!instanceof_function(Z_OBJCE_P(self->future_next_page), cassandra_future_rows_ce TSRMLS_CC)) { zend_throw_exception_ex(cassandra_runtime_exception_ce, 0 TSRMLS_CC, "Unexpected future instance."); return; } future_rows = (cassandra_future_rows*) zend_object_store_get_object(self->future_next_page TSRMLS_CC); if (php_cassandra_future_wait_timed(future_rows->future, timeout TSRMLS_CC) == FAILURE) { return; } if (php_cassandra_future_is_error(future_rows->future TSRMLS_CC) == FAILURE) { return; } result = cass_future_get_result(future_rows->future); } else { if (self->result == NULL) { return; } ASSERT_SUCCESS(cass_statement_set_paging_state((CassStatement*) self->statement->data, self->result)); session = (cassandra_session*) zend_object_store_get_object(self->session TSRMLS_CC); future = cass_session_execute(session->session, (CassStatement*) self->statement->data); if (php_cassandra_future_wait_timed(future, timeout TSRMLS_CC) == FAILURE) { return; } if (php_cassandra_future_is_error(future TSRMLS_CC) == FAILURE) { return; } result = cass_future_get_result(future); cass_future_free(future); } if (!result) { zend_throw_exception_ex(cassandra_runtime_exception_ce, 0 TSRMLS_CC, "Future doesn't contain a result."); return; } MAKE_STD_ZVAL(self->next_page); object_init_ex(self->next_page, cassandra_rows_ce); rows = (cassandra_rows*) zend_object_store_get_object(self->next_page TSRMLS_CC); if (php_cassandra_get_result(result, &rows->rows TSRMLS_CC) == FAILURE) { cass_result_free(result); zval_dtor(self->next_page); self->next_page = NULL; return; } if (self->future_next_page) { zval_ptr_dtor(&self->future_next_page); self->future_next_page = NULL; } if (cass_result_has_more_pages(result)) { Z_ADDREF_P(self->session); rows->statement = php_cassandra_add_ref(self->statement); rows->session = self->session; rows->result = result; } else { cass_result_free(result); } php_cassandra_rows_clear(self); RETURN_ZVAL(self->next_page, 1, 0); }