test_collections_mod Module Reference

Functions/Subroutines
subroutine	test_map_type_put
subroutine	test_map_type_put_unique
subroutine	test_map_type_pointers
subroutine	test_map_type_get
subroutine	test_map_type_remove
character(len=15) function	str (k)
subroutine	test_stack_type_pointers
subroutine	test_stack_type_push_pop
subroutine	test_queue_type_pointers
subroutine	test_queue_type_push_pop
subroutine	test_list_type_add
subroutine	test_list_type_pointers
subroutine	test_list_type_get
subroutine	test_list_type_insert
subroutine	test_list_type_remove
subroutine	init_random_seed ()

Function/Subroutine Documentation

init_random_seed()

subroutine test_collections_mod::init_random_seed

Definition at line 402 of file test_collections.F90.

    integer :: i, n, clock
    integer, dimension(:), allocatable :: seed
 
    call random_seed(size = n)
    allocate(seed(n))
 
    call system_clock(count=clock)
 
    seed = clock + 37 * (/ (i - 1, i = 1, n) /)
    call random_seed(put=seed)
 
    deallocate(seed)

Here is the caller graph for this function:

str()

character(len=15) function test_collections_mod::str

(

integer, intent(in)

k

)

Definition at line 158 of file test_collections.F90.

    integer, intent(in) :: k
    write (str, *) k
    str = adjustl(str)

Here is the caller graph for this function:

test_list_type_add()

subroutine test_collections_mod::test_list_type_add

Definition at line 263 of file test_collections.F90.

    type(list_type) :: my_list
    integer :: i
    class(*), pointer :: iptr
 
    call assert_equals(.true., c_is_empty(my_list), "List is empty")
 
    do i=1,10
      allocate(iptr, source=i)
      call c_add(my_list, iptr)
      call assert_equals(i, c_size(my_list), "List add increases list_type size")
    end do
 
    call assert_equals(.false., c_is_empty(my_list), "List is not empty after element adds")
 
    call c_free(my_list)

Here is the caller graph for this function:

test_list_type_get()

subroutine test_collections_mod::test_list_type_get

Definition at line 302 of file test_collections.F90.

    type(list_type) :: my_list
    integer :: i,j
    class(*), pointer :: iptr, data
 
    do i=1,10
      allocate(iptr, source=i)
      call c_add(my_list, iptr)
    end do
 
    call assert_equals(10, c_size(my_list), "List size increased after adding elements")
 
    do j=1,10
      data => c_get(my_list, j)
      select type(data)
        type is(integer)
          call assert_equals(j, data, "Element at location j is consistent with expectations")
        class default
          call add_fail("Type unknown")
      end select
    end do
 
    call c_free(my_list)

Here is the caller graph for this function:

test_list_type_insert()

subroutine test_collections_mod::test_list_type_insert

Definition at line 329 of file test_collections.F90.

    type(list_type) :: my_list
    integer :: i, element_to_remove, j, k
    class(*), pointer :: iptr=>null(), data=>null()
 
    do i=1,10
      allocate(iptr, source=i)
      call c_add(my_list, iptr)
    end do
 
    do i=1,10
      j=i*100
      allocate(iptr, source=j)
      call c_insert(my_list, iptr, i)
    end do
 
    call assert_equals(20, c_size(my_list), "Post addition and insertion list_type size is correct")
 
    do k=1,20
      data => c_get(my_list, k)
      select type(data)
        type is (integer)
          call assert_equals(data, merge(k-10, k*100, k .gt. 10), "Element at k is consistent with addition and insertion")
        class default
          call add_fail("Unknown type")
      end select
    end do
 
    call c_free(my_list)

Here is the caller graph for this function:

test_list_type_pointers()

subroutine test_collections_mod::test_list_type_pointers

Definition at line 281 of file test_collections.F90.

    type(list_type) :: my_list
    integer, target :: i
    class(*), pointer :: iptr, data
    i=20
    iptr=>i
    call c_add(my_list, iptr)
    i=50
    data=>c_get(my_list, 0)
    select type(data)
      type is (integer)
        call assert_equals(50, data, "List element modified by changing original value")
      class default
        call add_fail("Unknown type")
    end select
 
    call c_free(my_list)

Here is the caller graph for this function:

test_list_type_remove()

subroutine test_collections_mod::test_list_type_remove

Definition at line 362 of file test_collections.F90.

    type(list_type) :: my_list
    integer :: i, j, element_to_remove
    class(*), pointer :: iptr=>null(), data=>null()
    real :: r
 
    call init_random_seed
    call random_number(r)
    element_to_remove = int(r*9)+1
 
    do i=1,10
      allocate(iptr, source=i)
      call c_add(my_list, iptr)
    end do
 
    data => c_get(my_list, element_to_remove)
    select type(data)
      type is (integer)
        call assert_equals(element_to_remove, data, "Element to remove is consistent")
      class default
        call add_fail("Unknown type")
    end select
    call c_remove(my_list, element_to_remove)
 
    do j=1,9
      if (j .ne. element_to_remove) then
        data => c_get(my_list, j)
        select type(data)
          type is (integer)
          call assert_equals(merge(j, j+1, j .lt. element_to_remove), data, "After element removal element at j is consistent")
          class default
            call add_fail("Unknown type")
        end select
      end if
    end do
 
    call c_free(my_list)

Here is the call graph for this function:

Here is the caller graph for this function:

test_map_type_get()

subroutine test_collections_mod::test_map_type_get

Definition at line 80 of file test_collections.F90.

    type(map_type) :: my_map
    integer :: i, j, v, x
    class(*), pointer :: iptr, data
 
    call assert_equals(.true., c_is_empty(my_map), "map_type is empty")
 
    do i=1,10
      v = i * 10
      call assert_false(c_contains(my_map, str(i)), "map_type does not contain the key before put")
      allocate(iptr, source=v)
      call c_put(my_map, str(i), iptr)
      call assert_true(c_contains(my_map, str(i)), "map_type contains the key after put")
      data => c_get(my_map, str(i))
      select type (data)
        type is (integer)
          call assert_equals(i*10, data, "Value of entry is consistent")
      end select
      call assert_equals(str(i), c_key_at(my_map, i), "Key at location i is consistent")
    end do
 
    do j=1,10
      x = j * 100
      allocate(iptr, source=x)
      call c_put(my_map, str(j), iptr)
      data => c_get(my_map, str(j))
      select type (data)
        type is (integer)
          call assert_equals(j*100, data, "Value modified due to duplicate key")
        class default
          call add_fail("Unknown type")
      end select
      data => c_value_at(my_map, j)
      select type (data)
        type is (integer)
          call assert_equals(j*100, data, "Value at returned correct value at i")
        class default
          call add_fail("Unknown type")
      end select
    end do
 
    call c_free(my_map)

Here is the call graph for this function:

Here is the caller graph for this function:

test_map_type_pointers()

subroutine test_collections_mod::test_map_type_pointers

Definition at line 59 of file test_collections.F90.

    type(map_type) :: my_map
    integer, target :: i
    class(*), pointer :: iptr, data
    i=20
    iptr=>i
    call c_put(my_map, "A", iptr)
    i=50
    data=>c_get(my_map, "A")
    select type(data)
      type is (integer)
      call assert_equals(50, data, "Value of entry has been changed through modifying original variable")
      class default
      call add_fail("Unknown type")
    end select
    call c_free(my_map)

Here is the caller graph for this function:

test_map_type_put()

subroutine test_collections_mod::test_map_type_put

Definition at line 11 of file test_collections.F90.

    type(map_type) :: my_map
    integer :: i, j, v
    class(*), pointer :: iptr
 
    call assert_equals(.true., c_is_empty(my_map), "map_type is empty")
 
    do i=1,10
      allocate(iptr, source=i)
      call c_put(my_map, str(i), iptr)
      call assert_equals(i, c_size(my_map), "map_type size incremented with put")
    end do
 
    do j=1,10
      v = j * 10
      allocate(iptr, source=v)
      call c_put(my_map, str(j), iptr)
      call assert_equals(10, c_size(my_map), "map_type size remains unchanged after duplicate key")
    end do
 
    call c_free(my_map)

Here is the call graph for this function:

Here is the caller graph for this function:

test_map_type_put_unique()

subroutine test_collections_mod::test_map_type_put_unique

Definition at line 36 of file test_collections.F90.

    type(map_type) :: my_map
    integer :: i
    class(*), pointer :: iptr, data
 
    call assert_equals(.true., c_is_empty(my_map), "map_type is empty")
 
    do i=1,10
      allocate(iptr, source=i)
      call c_put(my_map, "A", iptr)
      data=>c_get(my_map, "A")
      select type(data)
        type is (integer)
          call assert_equals(i, data, "Value of key-value pair is correct")
        class default
          call add_fail("Unknown type")
      end select
      call assert_equals(1, c_size(my_map), "Size of may is one due to unique key")
    end do
 
    call c_free(my_map)

Here is the caller graph for this function:

test_map_type_remove()

subroutine test_collections_mod::test_map_type_remove

Definition at line 126 of file test_collections.F90.

    type(map_type) :: my_map
    integer :: i, j, v
    class(*), pointer :: iptr, data
 
    call assert_equals(.true., c_is_empty(my_map), "map_type is empty")
 
    do i=1,10
      v=i*10
      allocate(iptr, source=v)
      call c_put(my_map, str(i), iptr)
      data=>c_get(my_map, str(i))
      select type(data)
        type is (integer)
          call assert_equals(i*10, data, "Value of key is consistent")
        class default
          call add_fail("Unknown type")
      end select
    end do
 
    do j=1,10
      call assert_true(c_contains(my_map, str(11-j)), "map_type contains the key pre-removal")
      call c_remove(my_map, str(11-j))
      call assert_false(c_contains(my_map, str(11-j)), "map_type does not contain the key post-removal")
      call assert_equals(10-j, c_size(my_map), "Size of map_type is consistent post-removal")
    end do
    call assert_equals(.true., c_is_empty(my_map), "map_type is empty at the end")
 
    call c_free(my_map)

Here is the call graph for this function:

Here is the caller graph for this function:

test_queue_type_pointers()

subroutine test_collections_mod::test_queue_type_pointers

Definition at line 213 of file test_collections.F90.

    type(queue_type) :: my_queue
    integer, target :: i
    class(*), pointer :: iptr, data
    i=20
    iptr=>i
    call c_push(my_queue, iptr)
    i=50
    data=>c_pop(my_queue)
    select type(data)
      type is (integer)
      call assert_equals(50, data, "Queue data modified by changing the original variable")
      class default
      call add_fail("Unknown type")
    end select
 
    call c_free(my_queue)

Here is the caller graph for this function:

test_queue_type_push_pop()

subroutine test_collections_mod::test_queue_type_push_pop

Definition at line 233 of file test_collections.F90.

    type(queue_type) :: my_queue
    integer :: i,j
    class(*), pointer :: iptr, data
 
    call assert_equals(.true., c_is_empty(my_queue), "Queue is empty")
 
    do i=1,10
      allocate(iptr, source=i)
      call c_push(my_queue, iptr)
      call assert_equals(i, c_size(my_queue), "Queue size increases as elements are pushed")
    end do
 
    call assert_equals(.false., c_is_empty(my_queue), "Queue is not empty after elements pushed")
 
    do j=1,10
      data => c_pop(my_queue)
      select type(data)
        type is (integer)
          call assert_equals(data, j, "Queue popped element is FIFO")
          call assert_equals(10-j, c_size(my_queue), "Queue pop removes element")
        class default
          call add_fail("Type unknown")
      end select
    end do
 
    call c_free(my_queue)

Here is the caller graph for this function:

test_stack_type_pointers()

subroutine test_collections_mod::test_stack_type_pointers

Definition at line 164 of file test_collections.F90.

    type(stack_type) :: my_stack
    integer, target :: i
    class(*), pointer :: iptr, data
    i=20
    iptr=>i
    call c_push(my_stack, iptr)
    i=50
    data=>c_pop(my_stack)
    select type(data)
      type is (integer)
      call assert_equals(50, data, "Stack data modified through changing original variable")
      class default
      call add_fail("Unknown type")
    end select
 
    call c_free(my_stack)

Here is the caller graph for this function:

test_stack_type_push_pop()

subroutine test_collections_mod::test_stack_type_push_pop

Definition at line 184 of file test_collections.F90.

    type(stack_type) :: my_stack
    integer :: i,j
    class(*), pointer :: iptr, data
 
    call assert_equals(.true., c_is_empty(my_stack), "Stack is empty")
 
    do i=1,10
      allocate(iptr, source=i)
      call c_push(my_stack, iptr)
      call assert_equals(i, c_size(my_stack), "Size of stack_type increasing as data pushed")
    end do
 
    call assert_equals(.false., c_is_empty(my_stack), "Stack is not empty after values pushed")
 
    do j=1,10
      data => c_pop(my_stack)
      select type(data)
        type is (integer)
          call assert_equals(data, 11-j, "Stack pop gives LIFO value")
          call assert_equals(10-j, c_size(my_stack), "Stack pop removes the LIFO value")
        class default
          call add_fail("Type unknown")
      end select
    end do
 
    call c_free(my_stack)

Here is the caller graph for this function: