trema 0.1.3

data/unittests/switch_manager/switch_manager_test.c

@@ -0,0 +1,1178 @@
+/*
+ * Unit tests for switch_manager_test.
+ *
+ * Author: Kazushi SUGYO
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <netinet/tcp.h>
+#include "unittest.h"
+#include "trema.h"
+#include "switch_manager.h"
+#include "secure_channel_listener.h"
+
+extern struct listener_info listener_info;
+
+void usage();
+void handle_sigchld( int signum );
+void secure_channel_fd_set( fd_set *read_set, fd_set *write_set );
+void secure_channel_fd_isset( fd_set *read_set, fd_set *write_set );
+char *absolute_path( const char *dir, const char *file );
+int switch_manager_main( int argc, char *argv[] );
+void wait_child( void );
+
+
+/*************************************************************************
+ * Setup and teardown function.                                          
+ *************************************************************************/
+
+static void
+setup() {
+  init_log( "switch_manager_test", false );
+}
+
+
+static void
+teardown() {
+}
+
+
+/******************************************************************************
+ * Mock                                                                       
+ ******************************************************************************/
+
+void
+mock_die( char *format, ... ) {
+  UNUSED( format );
+}
+
+
+int
+mock_printf2( char *format, ... ) {
+  UNUSED( format );
+
+  return ( int ) mock();
+}
+
+
+/*************************************************************************
+ * Mock for switch_manager.c
+ *************************************************************************/
+
+int mock_wait3_status = 0;
+
+pid_t
+mock_wait3( int *status, int options, struct rusage *rusage ) {
+  check_expected( status );
+  check_expected( options );
+  check_expected( rusage );
+
+  *status = mock_wait3_status;
+
+  return ( pid_t ) mock();
+}
+
+
+void
+mock_secure_channel_accept( struct listener_info *listener_info ) {
+  check_expected( listener_info );
+
+  ( void ) mock();
+}
+
+int
+mock_access( const char *pathname, int mode) {
+  UNUSED( pathname );
+  UNUSED( mode );
+
+  return ( int ) mock();
+}
+
+char *
+mock_get_current_dir_name( void ) {
+  return ( char * ) mock();
+}
+
+void
+mock_init_trema( int *argc, char ***argv ) {
+  UNUSED( argc );
+  UNUSED( argv );
+
+  ( void ) mock();
+}
+
+void
+mock_set_fd_set_callback( void ( *callback )( fd_set *read_set, fd_set *write_set ) ) {
+  UNUSED( callback );
+
+  ( void ) mock();
+}
+
+void
+mock_set_check_fd_isset_callback( void ( *callback )( fd_set *read_set, fd_set *write_set ) ) {
+  UNUSED( callback );
+
+  ( void ) mock();
+}
+
+bool
+mock_secure_channel_listen_start( struct listener_info *listener_info ) {
+  UNUSED( listener_info );
+
+  return ( bool ) mock();
+}
+
+char *
+mock_get_trema_home( void ) {
+  return ( char * ) mock();
+}
+
+
+void
+mock_start_trema( void ) {
+  ( void ) mock();
+}
+
+
+const char *
+mock_get_executable_name( void ) {
+  return "switch_manager";
+}
+
+
+void
+mock_set_external_callback( void ( *callback ) ( void ) ) {
+  check_expected( callback );
+}
+
+/*************************************************************************
+ * Mock for secure_channel_listener.c
+ *************************************************************************/
+
+int
+mock_close( int fd ) {
+  check_expected( fd );
+
+  return ( int ) mock();
+}
+
+
+int
+mock_socket( int domain, int type, int protocol ) {
+  check_expected( domain );
+  check_expected( type );
+  check_expected( protocol );
+
+  return ( int ) mock();
+}
+
+
+int
+mock_bind( int sockfd, /* const */ struct sockaddr *addr, socklen_t addrlen ) {
+  struct sockaddr_in *addr_in = ( struct sockaddr_in * ) addr;
+  uint32_t sin_family32;
+  uint32_t sin_port32;
+
+  check_expected( sockfd );
+  check_expected( addr_in );
+  check_expected( addrlen );
+  sin_family32 = addr_in->sin_family;
+  check_expected( sin_family32 );
+  sin_port32 = addr_in->sin_port;
+  check_expected( sin_port32 );
+  check_expected( addr_in->sin_addr.s_addr );
+
+  return ( int ) mock();
+}
+
+
+int
+mock_listen( int sockfd, int backlog ) {
+  check_expected( sockfd );
+  check_expected( backlog );
+
+  return ( int ) mock();
+}
+
+
+int
+mock_accept( int sockfd, struct sockaddr *addr, socklen_t *addrlen ) {
+  check_expected( sockfd );
+  check_expected( addr );
+  check_expected( addrlen );
+  check_expected( *addrlen );
+
+  return ( int ) mock();
+}
+
+
+int
+mock_setsockopt( int sockfd, int level, int optname, /* const */ void *optval,
+  socklen_t optlen ) {
+
+  check_expected( sockfd );
+  check_expected( level );
+  check_expected( optname );
+  check_expected( optval );
+  check_expected( optlen );
+
+  return ( int ) mock();
+}
+
+
+pid_t
+mock_fork( void ) {
+  return ( pid_t ) mock();
+}
+
+
+int
+mock_dup2( int oldfd, int newfd ) {
+  check_expected( oldfd );
+  check_expected( newfd );
+
+  return ( int ) mock();
+}
+
+
+int
+mock_open( /* const */ char *pathname, int flags ) {
+  check_expected( pathname );
+  check_expected( flags );
+
+  return ( int ) mock();
+}
+
+
+int
+mock_execvp( /* const */ char *file, char * /* const */ argv[] ) {
+  check_expected( file );
+  check_expected( argv );
+  check_expected( argv[ 0 ] );
+  check_expected( argv[ 1 ] );
+
+  return ( int ) mock();
+}
+
+
+void
+mock_exit( int status ) {
+  check_expected( status );
+
+  ( void ) mock();
+}
+
+
+/*************************************************************************
+ * Test functions for switch_manager.c
+ *************************************************************************/
+
+static void
+test_usage() {
+  setup();
+
+  will_return( mock_printf2, 1 );
+
+  usage();
+
+  teardown();
+}
+
+
+static void
+test_handle_sigchld_succeeded() {
+  setup();
+
+  expect_value( mock_set_external_callback, callback, wait_child );
+
+  handle_sigchld( 3 );
+
+  teardown();
+}
+
+
+static void
+test_wait_child_succeeded() {
+  setup();
+
+  expect_not_value( mock_wait3, status, NULL );
+  expect_value( mock_wait3, options, WNOHANG );
+  expect_value( mock_wait3, rusage, NULL );
+
+  mock_wait3_status = 0;
+
+  will_return( mock_wait3, 1234 );
+
+  expect_not_value( mock_wait3, status, NULL );
+  expect_value( mock_wait3, options, WNOHANG );
+  expect_value( mock_wait3, rusage, NULL );
+
+  will_return( mock_wait3, 0 );
+
+  wait_child();
+
+  teardown();
+}
+
+
+static void
+test_wait_child_wait3_failed() {
+  setup();
+
+  expect_not_value( mock_wait3, status, NULL );
+  expect_value( mock_wait3, options, WNOHANG );
+  expect_value( mock_wait3, rusage, NULL );
+
+  mock_wait3_status = 0;
+
+  will_return( mock_wait3, -1 );
+
+  wait_child();
+
+  teardown();
+}
+
+
+static void
+test_wait_child_wait3_zero_return() {
+  setup();
+
+  expect_not_value( mock_wait3, status, NULL );
+  expect_value( mock_wait3, options, WNOHANG );
+  expect_value( mock_wait3, rusage, NULL );
+
+  mock_wait3_status = 0;
+
+  will_return( mock_wait3, 0 );
+
+  wait_child();
+
+  teardown();
+}
+
+
+static void
+test_wait_child_wait3_exit() {
+  setup();
+  
+  expect_not_value( mock_wait3, status, NULL );
+  expect_value( mock_wait3, options, WNOHANG );
+  expect_value( mock_wait3, rusage, NULL );
+
+  mock_wait3_status = 1 << 8;
+
+  will_return( mock_wait3, 1234 );
+
+  expect_not_value( mock_wait3, status, NULL );
+  expect_value( mock_wait3, options, WNOHANG );
+  expect_value( mock_wait3, rusage, NULL );
+
+  will_return( mock_wait3, 0 );
+
+  wait_child();
+
+  teardown();
+}
+
+
+static void
+test_wait_child_wait3_coredump() {
+  setup();
+
+  expect_not_value( mock_wait3, status, NULL );
+  expect_value( mock_wait3, options, WNOHANG );
+  expect_value( mock_wait3, rusage, NULL );
+
+  mock_wait3_status = 0x80 | 11;
+
+  will_return( mock_wait3, 5678 );
+
+  expect_not_value( mock_wait3, status, NULL );
+  expect_value( mock_wait3, options, WNOHANG );
+  expect_value( mock_wait3, rusage, NULL );
+
+  will_return( mock_wait3, 0 );
+
+  wait_child();
+
+  teardown();
+}
+
+
+static void
+test_wait_child_wait3_signaled() {
+  setup();
+
+  expect_not_value( mock_wait3, status, NULL );
+  expect_value( mock_wait3, options, WNOHANG );
+  expect_value( mock_wait3, rusage, NULL );
+
+  mock_wait3_status = 3;
+
+  will_return( mock_wait3, 4444 );
+
+  expect_not_value( mock_wait3, status, NULL );
+  expect_value( mock_wait3, options, WNOHANG );
+  expect_value( mock_wait3, rusage, NULL );
+
+  will_return( mock_wait3, 0 );
+
+  wait_child();
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_fd_set_succeeded() {
+  setup();
+
+  fd_set read_set, write_set;
+
+  listener_info.listen_fd = 1;
+  FD_ZERO( &read_set );
+  FD_ZERO( &write_set );
+  secure_channel_fd_set( &read_set, &write_set );
+
+  assert_true( FD_ISSET( listener_info.listen_fd, &read_set ) );
+  FD_CLR( listener_info.listen_fd, &read_set );
+  assert_true( FD_ISZERO( &read_set ) );
+  assert_true( FD_ISZERO( &write_set ) );
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_fd_set_failed() {
+  setup();
+
+  fd_set read_set, write_set;
+
+  listener_info.listen_fd = -1;
+  FD_ZERO( &read_set );
+  FD_ZERO( &write_set );
+  secure_channel_fd_set( &read_set, &write_set );
+
+  assert_true( FD_ISZERO( &read_set ) );
+  assert_true( FD_ISZERO( &write_set ) );
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_fd_isset_succeeded() {
+  setup();
+
+  fd_set read_set, write_set;
+
+  expect_value( mock_secure_channel_accept, listener_info, &listener_info );
+  will_return_void( mock_secure_channel_accept );
+
+  listener_info.listen_fd = 1;
+  FD_ZERO( &read_set );
+  FD_ZERO( &write_set );
+  FD_SET( listener_info.listen_fd, &read_set );
+  secure_channel_fd_isset( &read_set, &write_set );
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_fd_isset_failed() {
+  setup();
+
+  fd_set read_set, write_set;
+
+  listener_info.listen_fd = -1;
+  FD_ZERO( &read_set );
+  FD_ZERO( &write_set );
+  FD_SET( 1, &read_set );
+  secure_channel_fd_isset( &read_set, &write_set );
+
+  teardown();
+}
+
+
+static void
+test_absolute_path_absolute() {
+  setup();
+
+  char *path;
+
+  will_return( mock_access, 0 );
+
+  path = absolute_path( "/tmp", "/file" );
+  assert_string_equal( path, "/file" );
+  xfree( path );
+
+  teardown();
+}
+
+
+static void
+test_absolute_path_access_failed() {
+  setup();
+
+  char *path;
+
+  will_return( mock_access, -1 );
+
+  path = absolute_path( "/tmp", "/file" );
+  assert_true( path == NULL );
+
+  teardown();
+}
+
+
+static void
+test_absolute_path_relative() {
+  setup();
+
+  char *path;
+
+  will_return( mock_access, 0 );
+
+  path = absolute_path( "/tmp", "file" );
+  assert_string_equal( path, "/tmp/file" );
+  xfree( path );
+
+  will_return( mock_access, 0 );
+
+  path = absolute_path( "/tmp/", "./file" );
+  assert_string_equal( path, "/tmp/./file" );
+  xfree( path );
+
+  will_return( mock_access, 0 );
+
+  path = absolute_path( "/tmp", "../tmp/file" );
+  assert_string_equal( path, "/tmp/../tmp/file" );
+  xfree( path );
+
+  will_return( mock_access, 0 );
+
+  path = absolute_path( "/tmp/", "../../tmp/file" );
+  assert_string_equal( path, "/tmp/../../tmp/file" );
+  xfree( path );
+
+  teardown();
+}
+
+
+static void
+test_switch_manager_main_succeeded() {
+  setup();
+
+  char *argv[] = {
+      ( char * )( uintptr_t )"switch_manager",
+      ( char * )( uintptr_t )"--switch_manager=switch_manager",
+      NULL,
+    };
+  int argc = ARRAY_SIZE( argv ) - 1;
+  int ret;
+
+  will_return( mock_get_current_dir_name, strdup( "/tmp" ) );
+  will_return_void( mock_init_trema );
+  will_return( mock_access, 0 );
+
+  will_return_void( mock_set_fd_set_callback );
+  will_return_void( mock_set_check_fd_isset_callback );
+
+  will_return( mock_secure_channel_listen_start, true );
+  will_return( mock_get_trema_home, strdup( "/tmp" ) );
+  will_return_void( mock_start_trema );
+
+  optind = 1;
+  ret = switch_manager_main( argc, argv );
+
+  assert_true( ret == EXIT_SUCCESS );
+
+  teardown();
+}
+
+
+static void
+test_switch_manager_main_and_port_option_succeeded() {
+  setup();
+
+  char *argv[] = {
+      ( char * )( uintptr_t )"switch_manager",
+      ( char * )( uintptr_t )"--port=6633",
+      NULL,
+    };
+  int argc = ARRAY_SIZE( argv ) - 1;
+  int ret;
+
+  will_return( mock_get_current_dir_name, strdup( "/tmp" ) );
+  will_return_void( mock_init_trema );
+  will_return( mock_access, 0 );
+
+  will_return_void( mock_set_fd_set_callback );
+  will_return_void( mock_set_check_fd_isset_callback );
+
+  will_return( mock_secure_channel_listen_start, true );
+  will_return( mock_get_trema_home, strdup( "/tmp" ) );
+  will_return_void( mock_start_trema );
+
+  optind = 1;
+  ret = switch_manager_main( argc, argv );
+
+  assert_true( ret == EXIT_SUCCESS );
+
+  teardown();
+}
+
+
+static void
+test_switch_manager_main_and_port_option_failed() {
+  setup();
+
+  char *argv[] = {
+      ( char * )( uintptr_t )"switch_manager",
+      ( char * )( uintptr_t )"--port=0",
+      NULL,
+    };
+  int argc = ARRAY_SIZE( argv ) - 1;
+  int ret;
+
+  will_return( mock_get_current_dir_name, strdup( "/tmp" ) );
+  will_return_void( mock_init_trema );
+  will_return( mock_get_trema_home, strdup( "/tmp" ) );
+
+  optind = 1;
+  ret = switch_manager_main( argc, argv );
+
+  assert_true( ret == EXIT_FAILURE );
+
+  teardown();
+}
+
+
+static void
+test_switch_manager_main_help_and_exit() {
+  setup();
+
+  char *argv[] = {
+      ( char * )( uintptr_t )"switch_manager",
+      ( char * )( uintptr_t )"-x",
+      NULL,
+    };
+  int argc = ARRAY_SIZE( argv ) - 1;
+  int ret;
+
+  will_return( mock_printf2, 1 );
+  will_return( mock_get_current_dir_name, strdup( "/tmp" ) );
+  will_return_void( mock_init_trema );
+  will_return( mock_get_trema_home, strdup( "/tmp" ) );
+
+  expect_value( mock_exit, status, EXIT_SUCCESS );
+  will_return_void( mock_exit );
+
+  optind = 1;
+  ret = switch_manager_main( argc, argv );
+
+  assert_true( ret == EXIT_FAILURE );
+
+  teardown();
+}
+
+static void
+test_switch_manager_main_get_current_dir_name_failed() {
+  setup();
+
+  char *argv[] = {
+      ( char * )( uintptr_t )"switch_manager",
+      NULL,
+    };
+  int argc = ARRAY_SIZE( argv ) - 1;
+  int ret;
+
+  will_return( mock_get_current_dir_name, NULL );
+
+  optind = 1;
+  ret = switch_manager_main( argc, argv );
+
+  assert_true( ret == EXIT_FAILURE );
+
+  teardown();
+}
+
+
+static void
+test_switch_manager_main_secure_channel_listen_start_failed() {
+  setup();
+
+  char *argv[] = {
+      ( char * )( uintptr_t )"switch_manager",
+      NULL,
+    };
+  int argc = ARRAY_SIZE( argv ) - 1;
+  int ret;
+
+  will_return( mock_get_current_dir_name, strdup( "/tmp" ) );
+  will_return_void( mock_init_trema );
+  will_return( mock_get_trema_home, strdup( "/tmp" ) );
+  will_return( mock_access, 0 );
+
+  will_return_void( mock_set_fd_set_callback );
+  will_return_void( mock_set_check_fd_isset_callback );
+
+  will_return( mock_secure_channel_listen_start, false );
+
+  optind = 1;
+  ret = switch_manager_main( argc, argv );
+
+  assert_true( ret == EXIT_FAILURE );
+
+  teardown();
+}
+
+
+/*************************************************************************
+ * Test functions for secure_channel_listener.c
+ *************************************************************************/
+
+static void
+test_secure_channel_listen_start_succeeded() {
+  setup();
+
+  int listen_fd = 1;
+
+  listener_info.listen_fd = -1;
+
+  expect_value( mock_socket, domain, PF_INET );
+  expect_value( mock_socket, type, SOCK_STREAM );
+  expect_value( mock_socket, protocol, 0 );
+  will_return( mock_socket, listen_fd );
+
+  expect_value_count( mock_setsockopt, sockfd, listen_fd, 1 );
+  expect_value_count( mock_setsockopt, level, SOL_SOCKET, 1 );
+  expect_value_count( mock_setsockopt, optname, SO_REUSEADDR, 1 );
+  expect_not_value_count( mock_setsockopt, optval, NULL, 1 );
+  expect_value_count( mock_setsockopt, optlen, sizeof( int ), 1 );
+  will_return_count( mock_setsockopt, 0, 1 );
+
+  expect_value_count( mock_setsockopt, sockfd, listen_fd, 1 );
+  expect_value_count( mock_setsockopt, level, IPPROTO_TCP, 1 );
+  expect_value_count( mock_setsockopt, optname, TCP_NODELAY, 1 );
+  expect_not_value_count( mock_setsockopt, optval, NULL, 1 );
+  expect_value_count( mock_setsockopt, optlen, sizeof( int ), 1 );
+  will_return_count( mock_setsockopt, 0, 1 );
+
+  expect_value( mock_bind, sockfd, listen_fd );
+  expect_not_value( mock_bind, addr_in, NULL );
+  expect_value( mock_bind, addrlen, sizeof( struct sockaddr_in ) );
+  expect_value( mock_bind, sin_family32, AF_INET );
+  expect_value( mock_bind, sin_port32, ( uint32_t ) htons( OFP_TCP_PORT ) );
+  expect_value( mock_bind, addr_in->sin_addr.s_addr, htonl( INADDR_ANY ) );
+  will_return( mock_bind, 0 );
+
+  expect_value( mock_listen, sockfd, listen_fd );
+  expect_value( mock_listen, backlog, 128 );
+  will_return( mock_listen, 0 );
+
+  assert_true( secure_channel_listen_start( &listener_info ) );
+  assert_true( listener_info.listen_fd == listen_fd );
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_listen_start_socket_failed() {
+  setup();
+
+  int listen_fd = 1;
+
+  listener_info.listen_fd = listen_fd;
+
+  expect_value( mock_close, fd, listen_fd );
+  will_return_void( mock_close );
+
+  expect_value( mock_socket, domain, PF_INET );
+  expect_value( mock_socket, type, SOCK_STREAM );
+  expect_value( mock_socket, protocol, 0 );
+  will_return( mock_socket, -1 );
+
+  assert_false( secure_channel_listen_start( &listener_info ) );
+  assert_true( listener_info.listen_fd == -1 );
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_listen_start_setsockopt_bind_failed() {
+  setup();
+
+  int listen_fd = 1;
+
+  listener_info.listen_fd = -1;
+
+  expect_value( mock_socket, domain, PF_INET );
+  expect_value( mock_socket, type, SOCK_STREAM );
+  expect_value( mock_socket, protocol, 0 );
+  will_return( mock_socket, listen_fd );
+
+  expect_value_count( mock_setsockopt, sockfd, listen_fd, 1 );
+  expect_value_count( mock_setsockopt, level, SOL_SOCKET, 1 );
+  expect_value_count( mock_setsockopt, optname, SO_REUSEADDR, 1 );
+  expect_not_value_count( mock_setsockopt, optval, NULL, 1 );
+  expect_value_count( mock_setsockopt, optlen, sizeof( int ), 1 );
+  will_return_count( mock_setsockopt, -1, 1 );
+
+  expect_value_count( mock_setsockopt, sockfd, listen_fd, 1 );
+  expect_value_count( mock_setsockopt, level, IPPROTO_TCP, 1 );
+  expect_value_count( mock_setsockopt, optname, TCP_NODELAY, 1 );
+  expect_not_value_count( mock_setsockopt, optval, NULL, 1 );
+  expect_value_count( mock_setsockopt, optlen, sizeof( int ), 1 );
+  will_return_count( mock_setsockopt, -1, 1 );
+
+  expect_value( mock_bind, sockfd, listen_fd );
+  expect_not_value( mock_bind, addr_in, NULL );
+  expect_value( mock_bind, addrlen, sizeof( struct sockaddr_in ) );
+  expect_value( mock_bind, sin_family32, AF_INET );
+  expect_value( mock_bind, sin_port32, ( uint32_t ) htons( OFP_TCP_PORT ) );
+  expect_value( mock_bind, addr_in->sin_addr.s_addr, htonl( INADDR_ANY ) );
+  will_return( mock_bind, -1 );
+
+  expect_value( mock_close, fd, listen_fd );
+  will_return_void( mock_close );
+
+  assert_false( secure_channel_listen_start( &listener_info ) );
+  assert_true( listener_info.listen_fd == -1 );
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_listen_start_listen_failed() {
+  setup();
+
+  int listen_fd = 1;
+
+  listener_info.listen_fd = -1;
+
+  expect_value( mock_socket, domain, PF_INET );
+  expect_value( mock_socket, type, SOCK_STREAM );
+  expect_value( mock_socket, protocol, 0 );
+  will_return( mock_socket, listen_fd );
+
+  expect_value_count( mock_setsockopt, sockfd, listen_fd, 1 );
+  expect_value_count( mock_setsockopt, level, SOL_SOCKET, 1 );
+  expect_value_count( mock_setsockopt, optname, SO_REUSEADDR, 1 );
+  expect_not_value_count( mock_setsockopt, optval, NULL, 1 );
+  expect_value_count( mock_setsockopt, optlen, sizeof( int ), 1 );
+  will_return_count( mock_setsockopt, 0, 1 );
+
+  expect_value_count( mock_setsockopt, sockfd, listen_fd, 1 );
+  expect_value_count( mock_setsockopt, level, IPPROTO_TCP, 1 );
+  expect_value_count( mock_setsockopt, optname, TCP_NODELAY, 1 );
+  expect_not_value_count( mock_setsockopt, optval, NULL, 1 );
+  expect_value_count( mock_setsockopt, optlen, sizeof( int ), 1 );
+  will_return_count( mock_setsockopt, 0, 1 );
+
+  expect_value( mock_bind, sockfd, listen_fd );
+  expect_not_value( mock_bind, addr_in, NULL );
+  expect_value( mock_bind, addrlen, sizeof( struct sockaddr_in ) );
+  expect_value( mock_bind, sin_family32, AF_INET );
+  expect_value( mock_bind, sin_port32, ( uint32_t ) htons( OFP_TCP_PORT ) );
+  expect_value( mock_bind, addr_in->sin_addr.s_addr, htonl( INADDR_ANY ) );
+  will_return( mock_bind, 0 );
+
+  expect_value( mock_listen, sockfd, listen_fd );
+  expect_value( mock_listen, backlog, 128 );
+  will_return( mock_listen, -1 );
+
+  expect_value( mock_close, fd, listen_fd );
+  will_return_void( mock_close );
+
+  assert_false( secure_channel_listen_start( &listener_info ) );
+  assert_true( listener_info.listen_fd == -1 );
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_accept_parent_succeeded() {
+  setup();
+
+  int listen_fd = 0;
+  int accept_fd = 1;
+  int pid = 1;	/* parent */
+
+  listener_info.listen_fd = listen_fd;
+
+  expect_value( mock_accept, sockfd, listen_fd );
+  expect_not_value( mock_accept, addr, NULL );
+  expect_not_value( mock_accept, addrlen, NULL );
+  expect_value( mock_accept, *addrlen, sizeof( struct sockaddr_in ) );
+  will_return( mock_accept, accept_fd );
+
+  will_return( mock_fork, pid );
+
+  expect_value( mock_close, fd, accept_fd );
+  will_return_void( mock_close );
+
+  secure_channel_accept( &listener_info );
+}
+
+
+static void
+test_secure_channel_accept_accept_failed() {
+  int listen_fd = 0;
+
+  listener_info.listen_fd = listen_fd;
+
+  expect_value( mock_accept, sockfd, listen_fd );
+  expect_not_value( mock_accept, addr, NULL );
+  expect_not_value( mock_accept, addrlen, NULL );
+  expect_value( mock_accept, *addrlen, sizeof( struct sockaddr_in ) );
+  will_return( mock_accept, -1 );
+
+  secure_channel_accept( &listener_info );
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_accept_fork_failed() {
+  setup();
+
+  int listen_fd = 0;
+  int accept_fd = 3;
+
+  listener_info.listen_fd = listen_fd;
+
+  expect_value( mock_accept, sockfd, listen_fd );
+  expect_not_value( mock_accept, addr, NULL );
+  expect_not_value( mock_accept, addrlen, NULL );
+  expect_value( mock_accept, *addrlen, sizeof( struct sockaddr_in ) );
+  will_return( mock_accept, accept_fd );
+
+  will_return( mock_fork, -1 );
+
+  expect_value( mock_close, fd, accept_fd );
+  will_return_void( mock_close );
+
+  secure_channel_accept( &listener_info );
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_accept_child_succeeded() {
+  setup();
+
+  int listen_fd = 0;
+  int accept_fd = 3;
+  int pid = 0;	/* child */
+
+  listener_info.switch_manager = "switch_manager";
+  listener_info.switch_manager_argc = 0;
+  listener_info.listen_fd = listen_fd;
+
+  expect_value( mock_accept, sockfd, listen_fd );
+  expect_not_value( mock_accept, addr, NULL );
+  expect_not_value( mock_accept, addrlen, NULL );
+  expect_value( mock_accept, *addrlen, sizeof( struct sockaddr_in ) );
+  will_return( mock_accept, accept_fd );
+
+  will_return( mock_fork, pid );
+
+  expect_string( mock_open, pathname, "/dev/null" );
+  expect_value( mock_open, flags, O_RDONLY );
+  will_return( mock_open, 1 );
+
+  expect_value( mock_dup2, oldfd, 1 );
+  expect_value( mock_dup2, newfd, 0 );
+  will_return( mock_dup2, 0 );
+
+  expect_value( mock_close, fd, 1 );
+  will_return_void( mock_close );
+
+  expect_string( mock_open, pathname, "/dev/null" );
+  expect_value( mock_open, flags, O_WRONLY );
+  will_return( mock_open, 2 );
+
+  expect_value( mock_dup2, oldfd, 2 );
+  expect_value( mock_dup2, newfd, 1 );
+  will_return( mock_dup2, 1 );
+
+  expect_value( mock_close, fd, 2 );
+  will_return_void( mock_close );
+
+  expect_string( mock_open, pathname, "/dev/null" );
+  expect_value( mock_open, flags, O_WRONLY );
+  will_return( mock_open, 3 );
+
+  expect_value( mock_dup2, oldfd, 3 );
+  expect_value( mock_dup2, newfd, 2 );
+  will_return( mock_dup2, 2 );
+
+  expect_value( mock_close, fd, 3 );
+  will_return_void( mock_close );
+
+  expect_string( mock_execvp, file, listener_info.switch_manager );
+  expect_not_value( mock_execvp, argv, NULL );
+  expect_not_value( mock_execvp, argv[ 0 ], NULL );
+  expect_not_value( mock_execvp, argv[ 1 ], NULL );
+  will_return( mock_execvp, 0 );
+
+  expect_value( mock_exit, status, EXIT_FAILURE );
+  will_return_void( mock_exit );
+
+  secure_channel_accept( &listener_info );
+
+  teardown();
+}
+
+
+static void
+test_secure_channel_accept_child_and_args_succeeded() {
+  setup();
+  
+  int listen_fd = 0;
+  int accept_fd = 3;
+  int pid = 0;	/* child */
+  static char const *argv[] = { "a", "b" };
+
+  listener_info.switch_manager = "switch_manager";
+  listener_info.switch_manager_argc = 2;
+  listener_info.switch_manager_argv = ( char ** )( uintptr_t )argv;
+  listener_info.listen_fd = listen_fd;
+
+  expect_value( mock_accept, sockfd, listen_fd );
+  expect_not_value( mock_accept, addr, NULL );
+  expect_not_value( mock_accept, addrlen, NULL );
+  expect_value( mock_accept, *addrlen, sizeof( struct sockaddr_in ) );
+  will_return( mock_accept, accept_fd );
+
+  will_return( mock_fork, pid );
+
+  expect_string( mock_open, pathname, "/dev/null" );
+  expect_value( mock_open, flags, O_RDONLY );
+  will_return( mock_open, 1 );
+
+  expect_value( mock_dup2, oldfd, 1 );
+  expect_value( mock_dup2, newfd, 0 );
+  will_return( mock_dup2, 0 );
+
+  expect_value( mock_close, fd, 1 );
+  will_return_void( mock_close );
+
+  expect_string( mock_open, pathname, "/dev/null" );
+  expect_value( mock_open, flags, O_WRONLY );
+  will_return( mock_open, 2 );
+
+  expect_value( mock_dup2, oldfd, 2 );
+  expect_value( mock_dup2, newfd, 1 );
+  will_return( mock_dup2, 1 );
+
+  expect_value( mock_close, fd, 2 );
+  will_return_void( mock_close );
+
+  expect_string( mock_open, pathname, "/dev/null" );
+  expect_value( mock_open, flags, O_WRONLY );
+  will_return( mock_open, 3 );
+
+  expect_value( mock_dup2, oldfd, 3 );
+  expect_value( mock_dup2, newfd, 2 );
+  will_return( mock_dup2, 2 );
+
+  expect_value( mock_close, fd, 3 );
+  will_return_void( mock_close );
+
+  expect_string( mock_execvp, file, listener_info.switch_manager );
+  expect_not_value( mock_execvp, argv, NULL );
+  expect_not_value( mock_execvp, argv[ 0 ], NULL );
+  expect_not_value( mock_execvp, argv[ 1 ], NULL );
+  will_return( mock_execvp, 0 );
+
+  expect_value( mock_exit, status, EXIT_FAILURE );
+  will_return_void( mock_exit );
+
+  secure_channel_accept( &listener_info );
+
+  teardown();
+}
+
+
+/*************************************************************************
+ * Run tests.
+ *************************************************************************/
+
+int
+main() {
+  const UnitTest tests[] = {
+    /* Test functions for switch_manager.c */
+    unit_test( test_usage ),
+    unit_test( test_handle_sigchld_succeeded ),
+    unit_test( test_wait_child_succeeded ),
+    unit_test( test_wait_child_wait3_failed ),
+    unit_test( test_wait_child_wait3_zero_return ),
+    unit_test( test_wait_child_wait3_exit ),
+    unit_test( test_wait_child_wait3_coredump ),
+    unit_test( test_wait_child_wait3_signaled ),
+    unit_test( test_secure_channel_fd_set_succeeded ),
+    unit_test( test_secure_channel_fd_set_failed ),
+    unit_test( test_secure_channel_fd_isset_succeeded ),
+    unit_test( test_secure_channel_fd_isset_failed ),
+    unit_test( test_absolute_path_absolute ),
+    unit_test( test_absolute_path_access_failed ),
+    unit_test( test_absolute_path_relative ),
+    unit_test( test_switch_manager_main_succeeded ),
+    unit_test( test_switch_manager_main_and_port_option_succeeded ),
+    unit_test( test_switch_manager_main_and_port_option_failed ),
+    unit_test( test_switch_manager_main_help_and_exit ),
+    unit_test( test_switch_manager_main_get_current_dir_name_failed ),
+    unit_test( test_switch_manager_main_secure_channel_listen_start_failed ),
+    /* Test functions for secure_channel_listener.c */
+    unit_test( test_secure_channel_listen_start_succeeded ),
+    unit_test( test_secure_channel_listen_start_socket_failed ),
+    unit_test( test_secure_channel_listen_start_setsockopt_bind_failed ),
+    unit_test( test_secure_channel_listen_start_listen_failed ),
+    unit_test( test_secure_channel_accept_parent_succeeded ),
+    unit_test( test_secure_channel_accept_accept_failed ),
+    unit_test( test_secure_channel_accept_fork_failed ),
+    unit_test( test_secure_channel_accept_child_succeeded ),
+    unit_test( test_secure_channel_accept_child_and_args_succeeded ),
+  };
+
+  return run_tests( tests );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */