static void
make_path( routing_switch *routing_switch, uint64_t in_datapath_id, uint16_t in_port,
uint64_t out_datapath_id, uint16_t out_port, const buffer *packet ) {
dlist_element *hops = resolve_path( routing_switch->pathresolver, in_datapath_id, in_port, out_datapath_id, out_port );
if ( hops == NULL ) {
warn( "No available path found ( %#" PRIx64 ":%u -> %#" PRIx64 ":%u ).",
in_datapath_id, in_port, out_datapath_id, out_port );
discard_packet_in( in_datapath_id, in_port, packet );
return;
}
// count elements
uint32_t hop_count = count_hops( hops );
// send flow entry from tail switch
for ( dlist_element *e = get_last_element( hops ); e != NULL; e = e->prev, hop_count-- ) {
uint16_t idle_timer = ( uint16_t ) ( routing_switch->idle_timeout + hop_count );
modify_flow_entry( e->data, packet, idle_timer );
} // for(;;)
// send packet out for tail switch
dlist_element *e = get_last_element( hops );
pathresolver_hop *last_hop = e->data;
output_packet_from_last_switch( last_hop, packet );
// free them
free_hop_list( hops );
}
// "alpha" <-> "bravo" <-> "charlie"
static void
test_get_last_element() {
char element_data2[] = "bravo";
char element_data3[] = "charlie";
dlist_element *alpha = create_dlist();
dlist_element *bravo = insert_after_dlist( alpha, element_data2 );
dlist_element *charlie = insert_after_dlist( bravo, element_data3 );
assert_true( get_last_element( alpha ) == charlie );
assert_true( get_last_element( bravo ) == charlie );
assert_true( get_last_element( charlie ) == charlie );
delete_dlist( alpha );
}
static void
make_path( sliceable_switch *sliceable_switch, uint64_t in_datapath_id, uint16_t in_port, uint16_t in_vid,
uint64_t out_datapath_id, uint16_t out_port, uint16_t out_vid, const buffer *packet ) {
dlist_element *hops = resolve_path( sliceable_switch->pathresolver, in_datapath_id, in_port, out_datapath_id, out_port );
if ( hops == NULL ) {
warn( "No available path found ( %#" PRIx64 ":%u -> %#" PRIx64 ":%u ).",
in_datapath_id, in_port, out_datapath_id, out_port );
discard_packet_in( in_datapath_id, in_port, packet );
return;
}
// check if the packet is ARP or not
if ( sliceable_switch->handle_arp_with_packetout && packet_type_arp( packet ) ) {
// send packet out for tail switch
free_hop_list( hops );
output_packet( packet, out_datapath_id, out_port, out_vid );
return;
}
const uint32_t wildcards = 0;
struct ofp_match match;
set_match_from_packet( &match, in_port, wildcards, packet );
if ( lookup_path( in_datapath_id, match, PRIORITY ) != NULL ) {
warn( "Duplicated path found." );
output_packet( packet, out_datapath_id, out_port, out_vid );
return;
}
const uint16_t hard_timeout = 0;
path *p = create_path( match, PRIORITY, sliceable_switch->idle_timeout, hard_timeout );
assert( p != NULL );
for ( dlist_element *e = get_first_element( hops ); e != NULL; e = e->next ) {
pathresolver_hop *rh = e->data;
hop *h = create_hop( rh->dpid, rh->in_port_no, rh->out_port_no, NULL );
assert( h != NULL );
append_hop_to_path( p, h );
} // for(;;)
dlist_element *e = get_last_element( hops );
pathresolver_hop *last_hop = e->data;
packet_out_params *params = xmalloc( sizeof( struct packet_out_params ) );
params->packet = duplicate_buffer( packet );
params->out_datapath_id = last_hop->dpid;
params->out_port_no = last_hop->out_port_no;
params->out_vid = out_vid;
bool ret = setup_path( p, handle_setup, params, NULL, NULL );
if ( ret != true ) {
error( "Failed to set up path." );
output_packet( packet, out_datapath_id, out_port, out_vid );
free_buffer( params->packet );
xfree( params );
}
delete_path( p );
// free them
free_hop_list( hops );
}
void test_get_last_element_char(){
LinkedList list = createList();
char letter[] = "a";
char letter1[] = "b";
add_to_list(&list,letter);
add_to_list(&list,letter1);
assert(strcmp((char *)get_last_element(list),"b")==0);
}
void test_get_last_element(){
LinkedList list = createList();
void *item = (int *)malloc(sizeof(int));
*(int *)item = 20;
int length = add_to_list(&list, item);
assert(*(int *)get_last_element(list) == 20);
void *item1 = (int *)malloc(sizeof(int));
*(int *)item1 = 10;
length = add_to_list(&list, item1);
assert(*(int *)get_last_element(list) == 10);
printf("last item is changed afetr insertion of new element\n");
}
void test_get_last_element_float(){
LinkedList list = createList();
float a = 15.7,b=20.0;
add_to_list(&list,&a);
add_to_list(&list,&b);
float first = *(float *)get_last_element(list);
assert(first==b);
}
void test_get_last_element_emptystring(){
LinkedList list = createList();
char letter1[] = "babitha";
char letter[] = "";
add_to_list(&list,letter1);
add_to_list(&list,letter);
assert(strcmp((char *)get_last_element(list),"")==0);
}
void test_get_last_element(){
LinkedList list = createList();
int num = 10,num1 = 9,num2 = 8;
add_to_list(&list,&num);
add_to_list(&list,&num1);
add_to_list(&list,&num2);
int * result = get_last_element(list);
assert(8==*result);
}
datalog_element *datalog_definition::attach_element(datalog_element *e) {
e->next = NULL;
if(is_empty() == true) { // first element
element = e;
} else {
datalog_element *last = get_last_element();
last->next = e;
}
return e;
}
void test_get_last_element_string() {
LinkedList list = createList();
char value[] = "The";
char value1[] = "World";
char value2[] = "Beautiful";
add_to_list(&list, &value);
add_to_list(&list, &value1);
add_to_list(&list, &value2);
assert(value2 == (char *)get_last_element(list));
};
void test_get_last_element_double() {
LinkedList list = createList();
double value = 4.302;
double value1 = 3.211;
double value2 = 7.02;
add_to_list(&list, &value);
add_to_list(&list, &value1);
add_to_list(&list, &value2);
assert(7.02 == *(double *)get_last_element(list));
};
void last_element(void) {
LinkedList list = create();
int x = 3;
int y = 5;
add(&list, &x);
add(&list, &y);
Element *ele = get_last_element(list);
int *value = ele -> value;
assert(*value == 5);
};
void test_get_last_element_int() {
LinkedList list = createList();
int value = 4;
int value1 = 3;
int value2 = 7;
add_to_list(&list, &value);
add_to_list(&list, &value1);
add_to_list(&list, &value2);
assert(7 == *(int *)get_last_element(list));
};
void test_get_last_element(){
LinkedList list = createList();
int number = 44, number2 = 33, number3 = 23;
add_to_list(&list, &number);
add_to_list(&list, &number2);
add_to_list(&list, &number3);
void *last_element = get_last_element(list);
assert(_TYPEINT_(last_element) == 23);
};
static void
resolve_path_replied( void *user_data, dlist_element *hops ) {
assert( user_data != NULL );
resolve_path_replied_params *param = user_data;
routing_switch *routing_switch = param->routing_switch;
buffer *original_packet = param->original_packet;
if ( hops == NULL ) {
warn( "No available path found." );
free_buffer( original_packet );
xfree( param );
return;
}
original_packet->user_data = NULL;
if ( !parse_packet( original_packet ) ) {
warn( "Received unsupported packet" );
free_packet( original_packet );
free_hop_list( hops );
xfree( param );
return;
}
// count elements
uint32_t hop_count = count_hops( hops );
// send flow entry from tail switch
for ( dlist_element *e = get_last_element( hops ); e != NULL; e = e->prev, hop_count-- ) {
uint16_t idle_timer = ( uint16_t ) ( routing_switch->idle_timeout + hop_count );
modify_flow_entry( e->data, original_packet, idle_timer );
} // for(;;)
// send packet out for tail switch
dlist_element *e = get_last_element( hops );
pathresolver_hop *last_hop = e->data;
output_packet_from_last_switch( last_hop, original_packet );
// free them
free_hop_list( hops );
free_packet( original_packet );
xfree( param );
}
void test_get_last_element_char() {
LinkedList list = createList();
char value = 'S';
char value1 = 'A';
char value2 = 'X';
add_to_list(&list, &value);
add_to_list(&list, &value1);
add_to_list(&list, &value2);
assert('X' == *(char *)get_last_element(list));
};
void test_get_last_element_float() {
LinkedList list = createList();
float value = 4.302;
float value1 = 3.211;
float value2 = 7.02;
add_to_list(&list, &value);
add_to_list(&list, &value1);
add_to_list(&list, &value2);
assert(value2 == *(float *)get_last_element(list));
};
void test_for_get_last_element_returns_last_element_from_the_CHAR_type_of_list(){
Linked_list list = createList();
char _1st,_2nd,_3rd;
_1st ='a';
_2nd ='g';
_3rd ='9';
add_to_list(&list ,&_1st);
add_to_list(&list ,&_2nd);
add_to_list(&list ,&_3rd);
assert(TYPECHAR(get_last_element(list))=='9');
}
void test_for_get_last_element_returns_last_element_from_the_float_type_of_list(){
Linked_list list = createList();
float _1st,_2nd,_3rd;
_1st =905.5;
_2nd =87.0;
_3rd =78.50;
add_to_list(&list ,&_1st);
add_to_list(&list ,&_2nd);
add_to_list(&list ,&_3rd);
assert(TYPEFLOAT(get_last_element(list))==78.50);
}
void test_for_get_last_element_returns_last_element_from_the_double_type_of_list(){
Linked_list list = createList();
double _1st,_2nd,_3rd;
_1st =999999999999.555555559587439857349508734958374598347598373948573948;
_2nd =857349857349857349857349857349857349587.0;
_3rd =7840583409584309583409583409583409583405934.5093740932487329048320943029482309482309;
add_to_list(&list ,&_1st);
add_to_list(&list ,&_2nd);
add_to_list(&list ,&_3rd);
assert(TYPEDOUBLE(get_last_element(list))==_3rd);
}
void test_get_last_element() {
LinkedList list = createList();
int element = 12;
add_to_list(&list,&element);
int element1 = 13;
add_to_list(&list,&element1);
int element2 = 14;
add_to_list(&list,&element2);
int *value = get_last_element(list);
assert(14 == *value);
}
void test_reverse_using_getLastElement(){
LinkedList list = createList();
int number = 12, number2 = 33, number3 = 23, number4 = 44, number5 = 23;
add_to_list(&list, &number);
add_to_list(&list, &number2);
add_to_list(&list, &number3);
add_to_list(&list, &number4);
add_to_list(&list, &number5);
LinkedList reverse_list = reverse(list);
void *get_reverse_ele = get_last_element(reverse_list);
assert(_TYPEINT_(get_reverse_ele) == 12);
};
void test_for_get_last_element_returns_last_element_from_the_INT_type_of_list(){
Linked_list list = createList();
int _1st,_2nd,_3rd,_4th,_5th;
_1st =23;
_2nd =24;
_3rd =25;
_4th =26;
_5th =27;
add_to_list(&list ,&_1st);
add_to_list(&list ,&_2nd);
add_to_list(&list ,&_3rd);
add_to_list(&list ,&_4th);
add_to_list(&list ,&_5th);
assert(TYPEINT(get_last_element(list))==27);
}
void test_to_get_last_element_of_list() {
LinkedList list = createList();
int ele1 = 25;
int ele2 = 55;
int ele3 = 35;
int ele4 = 15;
int ele5 = 5;
add_to_list(&list,&ele1);
add_to_list(&list,&ele2);
add_to_list(&list,&ele3);
add_to_list(&list,&ele4);
add_to_list(&list,&ele5);
void *head = get_last_element(list);
assert(*(int *)head==5);
}
void test_get_lsst_element(){
LinkedList list = createList();
int *item =(int*)malloc( sizeof(int));
*item = 10;
float *value =(float*)malloc( sizeof(float));
*value = 11.23;
assert(1 == add_to_list(&list,item));
assert(2 == add_to_list(&list,value));
item =(int*)malloc( sizeof(int));
*item = 33;
assert(3 == add_to_list(&list,item));
Element * lastElement = get_last_element(list);
assert(33 == *(int*)lastElement->value);
}
void test_for_get_LAST_element_returns_LAST_element_from_the_STRUCTURE_type_of_list(){
Linked_list list = createList();
typedef struct Intern{
int age;
char *name;
char *companyName;
}intern;
intern i,j;
i.age=23;
i.name="Seeta";
i.companyName="ThoughtWorks";
int k=23;
add_to_list(&list ,&k);
add_to_list(&list,&i);
j=*(intern *)get_last_element(list);
assert(i.age==j.age);
assert(i.name==j.name);
assert(i.companyName==j.companyName);
}
static void
output_packet_from_last_switch( dlist_element *hops, const buffer *packet ) {
dlist_element *e = get_last_element( hops );
path_resolver_hop *last_hop = e->data;
output_packet( packet, last_hop->dpid, last_hop->out_port_no );
}
static void
test_get_last_element_aborts_with_NULL_dlist() {
expect_string( mock_die, output, "element must not be NULL" );
expect_assert_failure( get_last_element( NULL ) );
}
