TEST(TryingMessageBuildTestGroup, TryingMessageCallIdTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
struct CallIdHeader *inviteCallId = (struct CallIdHeader *)MessageGetHeader(HEADER_NAME_CALLID, invite);
struct CallIdHeader *tryingCallId = (struct CallIdHeader *)MessageGetHeader(HEADER_NAME_CALLID, trying);
CHECK_TRUE(CallIdHeaderMatched(inviteCallId, tryingCallId));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
value_t space_for_each_object(space_t *space, value_visitor_o *visitor) {
address_t current = space->start;
while (current < space->next_free) {
value_t value = new_heap_object(current);
TRY(value_visitor_visit(visitor, value));
heap_object_layout_t layout;
heap_object_layout_init(&layout);
get_heap_object_layout(value, &layout);
size_t size = layout.size;
CHECK_TRUE("object heap size alignment", is_size_aligned(kValueSize, size));
current += size;
}
return success();
}
static void
test_netaddr_create_host(void) {
struct netaddr netmask, host, result;
struct netaddr_str buf1, buf2, buf3;
char buffer1[17], buffer2[17];
size_t i;
memset(buffer1, 255, sizeof(buffer1));
memset(buffer2, 0, sizeof(buffer2));
START_TEST();
for (i=0; i<ARRAYSIZE(_create_host_test); i++) {
CHECK_TRUE(netaddr_from_string(&netmask, _create_host_test[i].netmask) == 0,
"error in parsing netmask %"PRINTF_SIZE_T_SPECIFIER" %s", i, _create_host_test[i].netmask);
CHECK_TRUE(netaddr_from_string(&result, _create_host_test[i].result) == 0,
"error in parsing result %"PRINTF_SIZE_T_SPECIFIER" %s", i, _create_host_test[i].result);
if (_create_host_test[i].buf_len >= 0) {
CHECK_TRUE(netaddr_create_host_bin(&host, &netmask, buffer1, _create_host_test[i].buf_len) == 0,
"error in creating host %"PRINTF_SIZE_T_SPECIFIER" %s with length %d",
i, netaddr_to_string(&buf1, &netmask), _create_host_test[i].buf_len);
}
else {
CHECK_TRUE(netaddr_create_host_bin(&host, &netmask, buffer2, -_create_host_test[i].buf_len) == 0,
"error in creating host %"PRINTF_SIZE_T_SPECIFIER" %s with length %d",
i, netaddr_to_string(&buf1, &netmask), _create_host_test[i].buf_len);
}
CHECK_TRUE(netaddr_cmp(&host, &result) == 0,
"Error, host %"PRINTF_SIZE_T_SPECIFIER" %s != result %s (netmask %s, len=%d)",
i, netaddr_to_string(&buf1, &host), netaddr_to_string(&buf2, &result),
netaddr_to_string(&buf3, &netmask), _create_host_test[i].buf_len);
}
END_TEST();
}
static void
test_netaddr_is_in_subnet(void) {
struct netaddr_str str1, str2;
size_t a, s;
START_TEST();
for (s = 0; s < sizeof(in_subnet_subnets) / sizeof(*in_subnet_subnets); s++) {
for (a = 0; a < sizeof(in_subnet_addrs) / sizeof(*in_subnet_addrs); a++) {
CHECK_TRUE(
in_subnet_results[a][s] == netaddr_binary_is_in_subnet(&in_subnet_subnets[s], &in_subnet_addrs[a], 4, AF_INET),
"%s is not in %s",
netaddr_to_string(&str1, &in_subnet_addrs[a]),
netaddr_to_string(&str2, &in_subnet_subnets[s]));
CHECK_TRUE(
in_subnet_results[a][s] == netaddr_is_in_subnet(&in_subnet_subnets[s], &in_subnet_addrs[a]),
"%s is not in %s",
netaddr_to_string(&str1, &in_subnet_addrs[a]),
netaddr_to_string(&str2, &in_subnet_subnets[s]));
}
}
END_TEST();
}
static void
test_delta_modify_two_sections(void) {
START_TEST();
handler_1.cb_delta_handler = handler_modify_two_sections;
cfg_db_add_entry(db_pre, SECTION_TYPE_1, NAME_1, KEY_1, value_1.value);
cfg_db_add_entry(db_pre, SECTION_TYPE_1, NAME_1, KEY_2, value_2.value);
cfg_db_add_entry(db_pre, SECTION_TYPE_1, NAME_2, KEY_2, value_2.value);
cfg_db_add_entry(db_pre, SECTION_TYPE_1, NAME_2, KEY_3, value_3.value);
cfg_db_add_entry(db_post, SECTION_TYPE_1, NAME_1, KEY_1, value_2.value);
cfg_db_add_entry(db_post, SECTION_TYPE_1, NAME_1, KEY_2, value_3.value);
cfg_db_add_entry(db_post, SECTION_TYPE_1, NAME_2, KEY_2, value_1.value);
cfg_db_add_entry(db_post, SECTION_TYPE_1, NAME_2, KEY_3, value_2.value);
CHECK_TRUE(cfg_schema_handle_db_changes(db_pre, db_post) == 0,
"delta calculation failed");
CHECK_TRUE(callback_counter == 2, "Callback counter was called %d times", callback_counter);
END_TEST();
}
TEST(TryingMessageBuildTestGroup, TryingMessageToWithTagTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE_WITH_TO_TAG, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
CONTACT_HEADER *inviteTo = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_TO, invite);
CONTACT_HEADER *tryingTo = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_TO, trying);
CHECK_TRUE(ContactHeaderMatched(inviteTo, tryingTo));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
IMPLEMENT_TEST(SQLiteObjectDbiUnitTests, canUndoRedo_oneUserStep) {
U2OpStatusImpl os;
U2ObjectDbi* objDbi = SQLiteObjectDbiTestData::getSQLiteObjectDbi();
// Create test msa
U2DataId msaId = SQLiteObjectDbiTestData::createTestMsa(true, os);
CHECK_NO_ERROR(os);
// Do action twice inside one UserStep
{
U2UseCommonUserModStep userStep(objDbi->getRootDbi(), msaId, os);
CHECK_NO_ERROR(os);
Q_UNUSED(userStep);
SQLiteObjectDbiTestData::addTestRow(msaId, os);
CHECK_NO_ERROR(os);
SQLiteObjectDbiTestData::addTestRow(msaId, os);
CHECK_NO_ERROR(os);
}
// Verify canUndo/canRedo
bool undoState = objDbi->canUndo(msaId, os); CHECK_NO_ERROR(os);
bool redoState = objDbi->canRedo(msaId, os); CHECK_NO_ERROR(os);
CHECK_TRUE(undoState, "undo state before undo");
CHECK_FALSE(redoState, "redo state before undo");
// Undo UserStep
objDbi->undo(msaId, os);
CHECK_NO_ERROR(os);
// Verify canUndo/canRedo
undoState = objDbi->canUndo(msaId, os); CHECK_NO_ERROR(os);
redoState = objDbi->canRedo(msaId, os); CHECK_NO_ERROR(os);
CHECK_FALSE(undoState, "undo state after undo");
CHECK_TRUE(redoState, "redo state after undo");
}
TEST(TryingMessageBuildTestGroup, TryingMessageStatusLineTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
struct StatusLine *status = MessageGetStatusLine(trying);
CHECK_TRUE(status != NULL);
STRCMP_EQUAL(SIP_VERSION, StatusLineGetSipVersion(status));
CHECK_EQUAL(100, StatusLineGetStatusCode(status));
STRCMP_EQUAL("Trying", StatusLineGetReasonPhrase(status));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
TEST(GameOfLifeEngine, AnyLiveCellWithThreeNeighboursLivesOnToNextGeneration) //AnyLiveCellWithTwoOrThreeNeighboursLivesOnToNextGeneration
{
int noOfXCells = 3;
int noOfYCells = 3;
GameOfLife game(noOfXCells, noOfYCells);
game.GiveCellLife(2,2);
game.GiveCellLife(1,1);
game.GiveCellLife(0,0);
game.GiveCellLife(0,2);
game.TriggerNextGeneration();
CHECK_TRUE(game.IsCellAlive(1,1));
}
static void addAddresses(struct rfc5444_writer *wr) {
struct netaddr ip;
struct rfc5444_writer_address *addr;
char value0 = 0, value1 = 1;
uint16_t metric;
CHECK_TRUE(0 == netaddr_from_string(&ip, "10.5.11.1"), "failed to initialize ip");
addr = rfc5444_writer_add_address(wr, cpr.creator, &ip, false);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_LOCAL_IF], &value1, 1, false);
CHECK_TRUE(0 == netaddr_from_string(&ip, "10.5.11.2"), "failed to initialize ip");
addr = rfc5444_writer_add_address(wr, cpr.creator, &ip, false);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_LOCAL_IF], &value1, 1, false);
CHECK_TRUE(0 == netaddr_from_string(&ip, "10.5.11.3"), "failed to initialize ip");
addr = rfc5444_writer_add_address(wr, cpr.creator, &ip, false);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_LOCAL_IF], &value0, 1, false);
CHECK_TRUE(0 == netaddr_from_string(&ip, "10.5.10.1"), "failed to initialize ip");
addr = rfc5444_writer_add_address(wr, cpr.creator, &ip, false);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_OTHERNEIGH], &value1, 1, false);
metric = htons(0x2024);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_METRIC1], &metric, sizeof(metric), true);
metric = htons(0x1013);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_METRIC2], &metric, sizeof(metric), true);
CHECK_TRUE(0 == netaddr_from_string(&ip, "10.5.12.1"), "failed to initialize ip");
addr = rfc5444_writer_add_address(wr, cpr.creator, &ip, false);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_OTHERNEIGH], &value1, 1, false);
metric = htons(0x202f);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_METRIC1], &metric, sizeof(metric), true);
metric = htons(0x1013);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_METRIC2], &metric, sizeof(metric), true);
CHECK_TRUE(0 == netaddr_from_string(&ip, "10.5.12.2"), "failed to initialize ip");
addr = rfc5444_writer_add_address(wr, cpr.creator, &ip, false);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_OTHERNEIGH], &value1, 1, false);
metric = htons(0x202f);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_METRIC1], &metric, sizeof(metric), true);
metric = htons(0x1013);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_METRIC2], &metric, sizeof(metric), true);
CHECK_TRUE(0 == netaddr_from_string(&ip, "10.5.12.3"), "failed to initialize ip");
addr = rfc5444_writer_add_address(wr, cpr.creator, &ip, false);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_OTHERNEIGH], &value1, 1, false);
metric = htons(0x202f);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_METRIC1], &metric, sizeof(metric), true);
metric = htons(0x1013);
rfc5444_writer_add_addrtlv(wr, addr, &addrtlvs[IDX_METRIC2], &metric, sizeof(metric), true);
}
TEST(GameOfLifeEngine, AnyDeadCellWithExactlyThreeLiveNeighboursBecomesALiveCell) //Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.
{
GameOfLife game(4,5);
game.GiveCellLife(0,1); //----------------
game.GiveCellLife(1,0); // | | |
game.GiveCellLife(1,1); //----------------
// * | * | |
//----------------
// | * | |
//----------------
game.TriggerNextGeneration();
CHECK_TRUE(game.IsCellAlive(0,0));
}
static void push_stack_piece_bottom_frame(runtime_t *runtime, value_t stack_piece,
value_t arg_map) {
frame_t bottom = frame_empty();
value_t code_block = ROOT(runtime, stack_piece_bottom_code_block);
// The transferred arguments are going to appear as if they were arguments
// passed from this frame so we have to "allocate" enough room for them on
// the stack.
open_stack_piece(stack_piece, &bottom);
size_t arg_count = get_array_length(arg_map);
bool pushed = try_push_new_frame(&bottom,
get_code_block_high_water_mark(code_block) + arg_count,
ffSynthetic | ffStackPieceBottom, false);
CHECK_TRUE("pushing bottom frame", pushed);
frame_set_code_block(&bottom, code_block);
frame_set_argument_map(&bottom, arg_map);
close_frame(&bottom);
}
void writeOnesBlocks(unsigned int startBlock, unsigned int blockCount)
{
unsigned int totalSize = blockCount * DISK_IMAGE_BLOCK_SIZE;
unsigned char* pBlockData = (unsigned char*)malloc(totalSize);
CHECK_TRUE(pBlockData != NULL);
memset(pBlockData, 0xff, totalSize);
DiskImageInsert insert;
insert.sourceOffset = 0;
insert.length = totalSize;
insert.type = DISK_IMAGE_INSERTION_BLOCK;
insert.block = startBlock;
insert.intraBlockOffset = 0;
__try_and_catch( BlockDiskImage_InsertData(m_pDiskImage, pBlockData, &insert) );
free(pBlockData);
}
void ShardDefinition::AddShard(size_t minPostingCount, double density)
{
CHECK_LT(m_shards.size(), c_maxShardIdCount)
<< "Shard count limit exceeded.";
CHECK_TRUE(m_shards.size() > 0 || minPostingCount == 0)
<< "First shard must have minPostingCount of zero.";
m_shards.push_back(std::make_pair(minPostingCount, density));
size_t i = m_shards.size() - 1;
while (i > 0 && m_shards[i].first < m_shards[i - 1].first)
{
std::swap(m_shards[i], m_shards[i - 1]);
--i;
}
}
void test_number_list() {
struct number_list* head = 0;
_add_number_list(&head, 23);
_add_number_list(&head, 42);
_add_number_list(&head, 17);
_add_number_list(&head, 32);
_add_number_list(&head, 1);
START_TEST();
int prev = 0;
struct number_list* node;
simple_list_for_each (head, node) {
CHECK_TRUE(node->value >= prev, "%d < %d", node->value, prev);
prev = node->value;
}
IMPLEMENT_TEST(SQLiteObjectDbiUnitTests, canUndoRedo_lastState) {
U2OpStatusImpl os;
U2ObjectDbi* objDbi = SQLiteObjectDbiTestData::getSQLiteObjectDbi();
// Create test msa
U2DataId msaId = SQLiteObjectDbiTestData::createTestMsa(true, os);
CHECK_NO_ERROR(os);
// Do action
SQLiteObjectDbiTestData::addTestRow(msaId, os);
CHECK_NO_ERROR(os);
// Verify canUndo/canRedo
bool undoState = objDbi->canUndo(msaId, os); CHECK_NO_ERROR(os);
bool redoState = objDbi->canRedo(msaId, os); CHECK_NO_ERROR(os);
CHECK_TRUE(undoState, "undo state");
CHECK_FALSE(redoState, "redo state");
}
static void
test_default_unnamed_named_section_set(void) {
const struct const_strarray *value;
START_TEST();
cfg_db_overwrite_entry(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_DEF, CFG_NAMED_VALUE);
cfg_db_overwrite_entry(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_NODEF, CFG_NAMED_VALUE);
cfg_db_overwrite_entry(db, CFG_SECTION, NULL, CFG_ENTRY_DEF, CFG_UNNAMED_VALUE);
cfg_db_overwrite_entry(db, CFG_SECTION, NULL, CFG_ENTRY_NODEF, CFG_UNNAMED_VALUE);
value = cfg_db_get_entry_value(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_DEF);
CHECK_TRUE(value != NULL, "No value found for named section entry with default");
if (value) {
CHECK_TRUE(value->value != NULL && strcmp(value->value, CFG_NAMED_VALUE) == 0,
"Did not got the named_section value with default: %s", value->value);
}
value = cfg_db_get_entry_value(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_NODEF);
CHECK_TRUE(value != NULL, "No value found for named section entry without default");
if (value) {
CHECK_TRUE(value->value != NULL && strcmp(value->value, CFG_NAMED_VALUE) == 0,
"Did not got the named_section value without default: %s", value->value);
}
value = cfg_db_get_entry_value(db, CFG_SECTION, NULL, CFG_ENTRY_DEF);
CHECK_TRUE(value != NULL, "No value found for unnamed section entry with default");
if (value) {
CHECK_TRUE(value->value != NULL && strcmp(value->value, CFG_UNNAMED_VALUE) == 0,
"Did not got the unnamed_section value with default: %s", value->value);
}
value = cfg_db_get_entry_value(db, CFG_SECTION, NULL, CFG_ENTRY_NODEF);
CHECK_TRUE(value != NULL, "No value found for unnamed section entry without default");
if (value) {
CHECK_TRUE(value->value != NULL && strcmp(value->value, CFG_UNNAMED_VALUE) == 0,
"Did not got the unnamed_section value without default: %s", value->value);
}
END_TEST();
}
value_t push_stack_frame(runtime_t *runtime, value_t stack, frame_t *frame,
size_t frame_capacity, value_t arg_map) {
CHECK_FAMILY(ofStack, stack);
value_t top_piece = get_stack_top_piece(stack);
CHECK_FALSE("stack piece closed", is_stack_piece_closed(top_piece));
if (!try_push_new_frame(frame, frame_capacity, ffOrganic, false)) {
// There wasn't room to push this frame onto the top stack piece so
// allocate a new top piece that definitely has room.
size_t default_capacity = get_stack_default_piece_capacity(stack);
size_t transfer_arg_count = get_array_length(arg_map);
size_t required_capacity
= frame_capacity // the new frame's locals
+ kFrameHeaderSize // the new frame's header
+ 1 // the synthetic bottom frame's one local
+ kFrameHeaderSize // the synthetic bottom frame's header
+ transfer_arg_count; // any arguments to be copied onto the piece
size_t new_capacity = max_size(default_capacity, required_capacity);
// Create and initialize the new stack segment. The frame struct is still
// pointing to the old frame.
TRY_DEF(new_piece, new_heap_stack_piece(runtime, new_capacity, top_piece,
stack));
push_stack_piece_bottom_frame(runtime, new_piece, arg_map);
transfer_top_arguments(new_piece, frame, transfer_arg_count);
set_stack_top_piece(stack, new_piece);
// Close the previous stack piece, recording the frame state.
close_frame(frame);
// Finally, create a new frame on the new stack which includes updating the
// struct. The required_capacity calculation ensures that this call will
// succeed.
open_stack_piece(new_piece, frame);
bool pushed_stack_piece = try_push_new_frame(frame, frame_capacity,
ffOrganic, false);
if (!pushed_stack_piece)
try_push_new_frame(frame, frame_capacity,
ffOrganic, false);
CHECK_TRUE("pushing on new piece failed", pushed_stack_piece);
}
frame_set_argument_map(frame, arg_map);
return success();
}
TEST(NetworkComponent, SetDirtyDelegatesToVariables)
{
NetworkComponent networkComponent1("", nullptr);
NetworkComponent networkComponent2("", nullptr);
Integer comp1var = 1;
Integer comp2var = 2;
networkComponent1.addVariable("var", &comp1var);
networkComponent2.addVariable("var", &comp2var);
comp1var.setDirty(true);
networkComponent1.setDirty(false);
comp2var.setDirty(false);
networkComponent2.setDirty(true);
CHECK_FALSE(comp1var.isDirty());
CHECK_TRUE(comp2var.isDirty());
}
IMPLEMENT_TEST(AnnotationGroupUnitTest, getSet_Name) {
const U2DbiRef dbiRef(getDbiRef());
SharedAnnotationData anData = createTestAnnotationData();
const QString groupName = "subgroup";
AnnotationTableObject ft("aname_table", dbiRef);
ft.addAnnotations(QList<SharedAnnotationData>() << anData, groupName);
AnnotationGroup *rootGroup = ft.getRootGroup();
CHECK_TRUE(rootGroup->hasValidId(), "Invalid root group ID");
const QList<AnnotationGroup *> subgroups = rootGroup->getSubgroups();
CHECK_EQUAL(1, subgroups.size(), "Count of subgroups");
AnnotationGroup *group = subgroups.first();
CHECK_EQUAL(groupName, group->getName(), "annotation group name");
const QString newName = "misc_feature";
group->setName(newName);
CHECK_EQUAL(newName, group->getName(), "annotation group name");
}
TEST(NetworkComponent, CorrectlyWritesDirtyReplications)
{
NetworkComponent networkComponent("", nullptr);
Integer var1 = 1;
Integer var2 = 2;
networkComponent.addVariable("var1", &var1);
networkComponent.addVariable("var2", &var2);
var1.setDirty(false);
var2.setDirty(true);
Buffer buffer;
networkComponent.writeReplications(&buffer, true);
ParameterContainer c(&buffer);
CHECK_FALSE(c.has("var1"));
CHECK_TRUE(c.has("var2"));
}
TEST(MEKFGyroAccMagTestGroup, vect_measurement_jacobian)
{
Eigen::Quaternionf att(Eigen::AngleAxisf(M_PI/2, Eigen::Vector3f::UnitZ()));
Eigen::Vector3f v_i(0, 1, 0); // expectation of v in inertial frame
// expectation of v is along [0,1,0] in inertial and [1,0,0] in body frame,
// because the body frame is oriented +90deg yaw
k.reset(att);
Eigen::Vector3f v_b = att.conjugate()._transformVector(v_i); // [1,0,0]
Eigen::Matrix3f b_to_m = k.vect_measurement_basis_b_frame(v_i);
//std::cout << std::endl << v_b << std::endl;
Eigen::Matrix<float, 2, 3> Ha = MEKFGyroAccMag::vect_measurement_jacobian(b_to_m, v_b);
Eigen::Matrix<float, 2, 3> Ha_exp;
// sensitivity of z (= last 2 components of v_m) with respect to a:
// with respect to a1 (=roll right) = [0, 0]' (v_b is [1, 0, 0], along roll axis)
// with respect to a2 (=pitch up) = [0, 1]' (v_b goes down (positive))
// with respect to a3 (=yaw right) = [-1, 0]' (v_b goes left (negative))
Ha_exp << 0, 0, -1,
0, 1, 0;
//std::cout << std::endl << Ha << std::endl;
CHECK_TRUE(Ha.isApprox(Ha_exp));
}
int wlan_set_credentials(WLanCredentials* halCred) {
if (!isSupportedSecurityType((WLanSecurityType)halCred->security) ||
(halCred->security != WLanSecurityType::WLAN_SEC_UNSEC && halCred->password_len == 0) ||
halCred->ssid_len == 0) {
return SYSTEM_ERROR_INVALID_ARGUMENT;
}
WifiCredentials cred;
if (halCred->security != WLanSecurityType::WLAN_SEC_UNSEC) {
const auto pwd = CString::wrap(strndup(halCred->password, halCred->password_len));
cred.type(WifiCredentials::PASSWORD);
cred.password(pwd);
}
const auto ssid = CString::wrap(strndup(halCred->ssid, halCred->ssid_len));
WifiNetworkConfig conf;
conf.ssid(ssid);
conf.security(toWifiSecurity(halCred->security));
conf.credentials(std::move(cred));
const auto mgr = wifiNetworkManager();
CHECK_TRUE(mgr, SYSTEM_ERROR_UNKNOWN);
CHECK(mgr->setNetworkConfig(std::move(conf)));
return 0;
}
// Adds mappings in the namespace and imports in the methodspace for everything
// imported by the given fragment.
static value_t bind_module_fragment_imports(binding_context_t *context,
value_t imports, value_t bound_fragment) {
// Import the modules spaces into this fragment and create bindings in the
// importspace.
value_t methodspace = get_module_fragment_methodspace(bound_fragment);
value_t importspace = get_module_fragment_imports(bound_fragment);
runtime_t *runtime = get_ambience_runtime(context->ambience);
for (size_t i = 0; i < get_array_buffer_length(imports); i++) {
// Look up the imported module.
value_t import_ident = get_array_buffer_at(imports, i);
value_t import_path = get_identifier_path(import_ident);
value_t import_head = get_path_head(import_path);
value_t import_stage = get_identifier_stage(import_ident);
value_t import_module = get_id_hash_map_at(context->bound_module_map, import_path);
value_t import_fragment = get_module_fragment_at(import_module, import_stage);
CHECK_TRUE("import not bound", is_module_fragment_bound(import_fragment));
value_t import_methods = get_module_fragment_methodspace(import_fragment);
TRY(add_methodspace_import(runtime, methodspace, import_methods));
TRY(set_id_hash_map_at(runtime, importspace, import_head,
import_fragment));
}
return success();
}
void on_derived_object_exit(value_t self) {
CHECK_DOMAIN(vdDerivedObject, self);
genus_descriptor_t *descriptor = get_derived_object_descriptor(self);
CHECK_TRUE("derived object not scoped", descriptor->on_scope_exit != NULL);
(descriptor->on_scope_exit)(self);
}
// Returns the next byte from the given byte stream.
byte_t byte_stream_read(byte_stream_t *stream) {
CHECK_TRUE("byte stream empty", byte_stream_has_more(stream));
byte_t result = blob_byte_at(stream->blob, stream->cursor);
stream->cursor++;
return result;
}
static void
handler_modify_two_sections(void) {
bool n1, n2;
CHECK_TRUE(callback_counter < 2, "Callback was called %d times!", callback_counter+1);
callback_counter++;
if (callback_counter > 2) {
return;
}
CHECK_TRUE(handler_1.pre != NULL, "No pre named-section found.");
CHECK_TRUE(handler_1.post != NULL, "No post named-section found.");
if (handler_1.pre == NULL || handler_1.post == NULL) {
return;
}
n1 = handler_1.pre->name != NULL && strcmp(handler_1.pre->name, NAME_1) == 0
&& handler_1.post->name != NULL && strcmp(handler_1.post->name, NAME_1) == 0;
n2 = handler_1.pre->name != NULL && strcmp(handler_1.pre->name, NAME_2) == 0
&& handler_1.pre->name != NULL && strcmp(handler_1.pre->name, NAME_2) == 0;
CHECK_TRUE(n1 || n2, "Illegal name of changed section: %s %s", handler_1.pre->name, handler_1.post->name);
if (n1) {
CHECK_TRUE(!callback_marker[0], "section with first name triggered twice");
callback_marker[0] = true;
CHECK_TRUE( entries_1[0].delta_changed, "Key 1 did not change!");
CHECK_TRUE( entries_1[1].delta_changed, "Key 2 did not change!");
CHECK_TRUE(!entries_1[2].delta_changed, "Key 3 did change!");
CHECK_TRUE(strarray_cmp_c(entries_1[0].pre, &value_1) == 0,
"Unknown pre data for key 1: %s", entries_1[0].pre->value);
CHECK_TRUE(strarray_cmp_c(entries_1[1].pre, &value_2) == 0,
"Unknown pre data for key 2: %s", entries_1[1].pre->value);
CHECK_TRUE(strarray_cmp_c(entries_1[0].post, &value_2) == 0,
"Unknown post data for key 1: %s", entries_1[0].post->value);
CHECK_TRUE(strarray_cmp_c(entries_1[1].post, &value_3) == 0,
"Unknown post data for key 2: %s", entries_1[1].post->value);
}
else if (n2) {
CHECK_TRUE(!callback_marker[1], "section with second name triggered twice");
callback_marker[1] = true;
CHECK_TRUE(!entries_1[0].delta_changed, "Key 1 did change!");
CHECK_TRUE( entries_1[1].delta_changed, "Key 2 did not change!");
CHECK_TRUE( entries_1[2].delta_changed, "Key 3 did not change!");
CHECK_TRUE(strarray_cmp_c(entries_1[1].pre, &value_2) == 0,
"Unknown pre data for key 2: %s", entries_1[0].pre->value);
CHECK_TRUE(strarray_cmp_c(entries_1[2].pre, &value_3) == 0,
"Unknown pre data for key 3: %s", entries_1[1].pre->value);
CHECK_TRUE(strarray_cmp_c(entries_1[1].post, &value_1) == 0,
"Unknown post data for key 2: %s", entries_1[0].post->value);
CHECK_TRUE(strarray_cmp_c(entries_1[2].post, &value_2) == 0,
"Unknown post data for key 3: %s", entries_1[1].post->value);
}
}
static void
handler_modify_section(void) {
callback_counter++;
CHECK_TRUE(callback_counter == 1, "Callback was called %d times!", callback_counter);
if (callback_counter > 1) {
return;
}
CHECK_TRUE(handler_1.pre != NULL, "No pre named-section found.");
CHECK_TRUE(handler_1.post != NULL, "No post named-section found.");
if (handler_1.post == NULL || handler_1.pre == NULL) {
return;
}
CHECK_TRUE(handler_1.pre->name != NULL && strcmp(handler_1.pre->name, NAME_1) == 0,
"Illegal name of changed pre section: %s", handler_1.pre->name);
CHECK_TRUE(handler_1.post->name != NULL && strcmp(handler_1.post->name, NAME_1) == 0,
"Illegal name of changed post section: %s", handler_1.post->name);
CHECK_TRUE( entries_1[0].delta_changed, "Key 1 did not change!");
CHECK_TRUE( entries_1[1].delta_changed, "Key 2 did not change!");
CHECK_TRUE(!entries_1[2].delta_changed, "Key 3 did change!");
CHECK_TRUE(strarray_cmp_c(entries_1[0].pre, &value_2) == 0,
"Unknown pre data for key 1: %s", entries_1[0].pre->value);
CHECK_TRUE(strarray_cmp_c(entries_1[1].pre, &value_3) == 0,
"Unknown pre data for key 1: %s", entries_1[1].pre->value);
CHECK_TRUE(strarray_cmp_c(entries_1[0].post, &value_1) == 0,
"Unknown post data for key 1: %s", entries_1[0].post->value);
CHECK_TRUE(strarray_cmp_c(entries_1[1].post, &value_2) == 0,
"Unknown post data for key 1: %s", entries_1[1].post->value);
}
TEST(mockIComm, IsGdbConnected_ShouldDefaultToReturnTrue)
{
CHECK_TRUE(IComm_IsGdbConnected(mockIComm_Get()));
}
TEST(mockIComm, IsGdbConnected_SetToReturnTrue)
{
mockIComm_SetIsGdbConnectedFlag(1);
CHECK_TRUE(IComm_IsGdbConnected(mockIComm_Get()));
}
