Changeset 19846

Show
Ignore:
Timestamp:
03/02/07 11:52:27 (2 years ago)
Author:
patrick
Message:

Changed the read, write, and state query methods for all I/O classes
(vpr::BlockIO, vpr::Socket, vpr::SocketStream?, vpr::SocketDatagram?, and
vpr::SerialPort?) to return the result (bytes read, bytes written, state
value) "out the back" rather than through a by-reference parameter. We can
finally do this now that we are using exception handling instead of having
to use the return type for vpr::ReturnStatus?.

Bumped version to 1.1.42.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • juggler/trunk/modules/vapor/ChangeLog

    r19810 r19846  
    11DATE       AUTHOR   CHANGE 
    22---------- -------- ----------------------------------------------------------- 
     32007-03-02 patrick  Changed the signature of the read, write, and query methods 
     4                    on I/O classes (vpr::BlockIO, vpr::Socket, 
     5                    vpr::SocketStream, vpr::SocketDatagram, and 
     6                    vpr::SerialPort) to return the result "out the back" 
     7                    instead of through a by-reference parameter. 
     8                    NEW VERSION: 1.1.42 
    392007-02-13 patrick  Use the Win32 thread and sychronization APIs directly 
    410                    instead of using NSPR. 

  • juggler/trunk/modules/vapor/VERSION

    r19810 r19846  
     11.1.42-0 @03/02/2007 17:55:00 UTC@ 
    121.1.41-0 @02/13/2007 23:15:00 UTC@ 
    231.1.40-0 @02/13/2007 21:40:00 UTC@ 

  • juggler/trunk/modules/vapor/test/SerialPort/first.cpp

    r19729 r19846  
    5656      port->open(); 
    5757      char read_buffer[10], write_buffer[10]; 
    58       vpr::Uint32 bytes; 
    5958      int val; 
    6059 
    …… 
    6968      { 
    7069         memset((void*) &read_buffer, '\0', sizeof(read_buffer)); 
    71          port->read(read_buffer, sizeof(read_buffer), bytes); 
     70         port->read(read_buffer, sizeof(read_buffer)); 
    7271         std::cerr << "Read '" << read_buffer << "'\n"; 
    7372 
    …… 
    7776         memset((void*) &write_buffer, '\0', sizeof(write_buffer)); 
    7877         sprintf(write_buffer, "%d", val); 
    79          port->write(write_buffer, strlen(write_buffer) + 1, bytes); 
    80          std::cerr << "Wrote '" << write_buffer << "' (" << bytes << " bytes)\n"; 
     78         const vpr::Uint32 bytes = port->write(write_buffer, 
     79                                               strlen(write_buffer) + 1); 
     80         std::cerr << "Wrote '" << write_buffer << "' (" << bytes 
     81                   << " bytes)\n"; 
    8182      } 
    8283   } 

  • juggler/trunk/modules/vapor/test/SerialPort/reader.cpp

    r19729 r19846  
    5252      read_port->open(); 
    5353      char buffer[80]; 
    54       vpr::Uint32 bytes; 
    5554 
    5655      std::cout << "Port opened\n"; 
    …… 
    6261      read_port->setCanonicalInput(false); 
    6362      //read_port->flushQueue(vpr::SerialTypes::INPUT_QUEUE); 
    64       read_port->read(buffer, sizeof(buffer), bytes); 
     63      read_port->read(buffer, sizeof(buffer)); 
    6564      std::cout << "Read '" << buffer << "'" << std::endl; 
    6665   } 

  • juggler/trunk/modules/vapor/test/SerialPort/second.cpp

    r19729 r19846  
    5757      char read_buffer[10], write_buffer[10]; 
    5858      int val; 
    59       vpr::Uint32 bytes; 
    6059 
    6160      std::cerr << "Port opened\n"; 
    …… 
    7170         memset((void*) &write_buffer, '\0', sizeof(write_buffer)); 
    7271         sprintf(write_buffer, "%d", val); 
    73          port->write(write_buffer, strlen(write_buffer) + 1, bytes); 
     72         const vpr::Uint32 bytes = port->write(write_buffer, 
     73                                               strlen(write_buffer) + 1); 
    7474         std::cerr << "Wrote '" << write_buffer << "' (" << bytes 
    7575                   << " bytes)\n"; 
    7676 
    7777         memset((void*) &read_buffer, '\0', sizeof(read_buffer)); 
    78          port->read(read_buffer, sizeof(read_buffer), bytes); 
     78         port->read(read_buffer, sizeof(read_buffer)); 
    7979         std::cerr << "Read '" << read_buffer << "'\n"; 
    8080 

  • juggler/trunk/modules/vapor/test/SerialPort/writer.cpp

    r19729 r19846  
    5959         write_port->open(); 
    6060         char buffer[] = "This is a test..."; 
    61          vpr::Uint32 bytes; 
    6261         vpr::Uint16 size; 
    6362 
    …… 
    7271         write_port->setCharacterSize(vpr::SerialTypes::CS_BITS_8); 
    7372         std::cout << "Pre Write memleak :" << memleak << std::endl; 
    74          write_port->write(buffer, sizeof(char) * (strlen(buffer) + 1), bytes); 
     73         const vpr::Uint32 bytes = 
     74            write_port->write(buffer, sizeof(char) * (strlen(buffer) + 1)); 
    7575         std::cout << std::flush; 
    7676         std::cout << "Post Write memleak :" << memleak << std::endl; 

  • juggler/trunk/modules/vapor/test/Socket/tcp_client.cpp

    r19729 r19846  
    8282         { 
    8383            char buffer[40];  
    84             vpr::Uint32 bytes; 
    85             sock.read(buffer, 40, bytes, 
    86                       vpr::Interval(5, vpr::Interval::Sec)); 
     84            const vpr::Uint32 bytes = 
     85               sock.read(buffer, 40, vpr::Interval(5, vpr::Interval::Sec)); 
    8786 
    8887            // If we read anything, print it. 
    …… 
    9190               std::cout << "Read " << bytes << " bytes from server\n" 
    9291                         << "     Got '" << buffer << "'" << std::endl; 
    93             } 
    94             else if ( bytes == -1 ) 
    95             { 
    96                std::cout << "Error reading!" << std::endl; 
    9792            } 
    9893            else 

  • juggler/trunk/modules/vapor/test/Socket/tcp_server.cpp

    r19729 r19846  
    7878            // Using the new socket, send the buffer to the client and close 
    7979            // the socket. 
    80             vpr::Uint32 bytes; 
    81             client_sock.write(buffer, sizeof(buffer), bytes); 
    82 //            client_sock.write(buffer, buffer.length(), bytes); 
     80            client_sock.write(buffer, sizeof(buffer)); 
     81//            client_sock.write(buffer, buffer.length()); 
    8382            client_sock.close(); 
    8483         } 

  • juggler/trunk/modules/vapor/test/Socket/udp_client.cpp

    r19729 r19846  
    6565 
    6666         char buffer[40]; 
    67          vpr::Uint32 bytes; 
    68  
    6967         memset(buffer, '\0', sizeof(buffer)); 
    7068         strcpy(buffer, "Hi, I'm a client"); 
    7169 
    7270         // Write to the server. 
    73          sock.write(buffer, 40, bytes); 
     71         sock.write(buffer, 40); 
    7472 
    7573         // Read from the server. 
    76          sock.read(buffer, 40, bytes); 
     74         const vpr::Uint32 bytes = sock.read(buffer, 40); 
    7775 
    7876         // If the server reasponded, print the result. 

  • juggler/trunk/modules/vapor/test/Socket/udp_server.cpp

    r19729 r19846  
    6868      char recv_buf[32]; 
    6969      char send_buf[] = "Hello there!"; 
    70       vpr::Uint32 bytes; 
    7170 
    7271      // Loop forever reading messages from clients. 
    …… 
    7877         { 
    7978            // Read a message from a client. 
    80             sock.recvfrom(recv_buf, sizeof(recv_buf), addr, bytes); 
     79            const vpr::Uint32 bytes = sock.recvfrom(recv_buf, sizeof(recv_buf), 
     80                                                    addr); 
    8181 
    8282            // If we read anything, print it and send a response. 
    …… 
    8585                      << std::endl; 
    8686 
    87             sock.sendto(send_buf, sizeof(send_buf), addr, bytes); 
     87            sock.sendto(send_buf, sizeof(send_buf), addr); 
    8888         } 
    8989         catch (vpr::IOException& ex) 

  • juggler/trunk/modules/vapor/test/TestSuite/TestCases/IO/Port/SerialPortTest.cpp

    r19550 r19846  
    193193 
    194194   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port opening failed", port.open()); 
    195    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Buffer size query failed", port.getMinInputSize(buf_size)); 
     195   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Buffer size query failed", 
     196                                   buf_size = port.getMinInputSize()); 
    196197 
    197198   buf_size++; 
    198    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Buffer size update failed", port.setMinInputSize(buf_size)); 
    199  
    200    port.getMinInputSize(buf_size_new); 
     199   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Buffer size update failed", 
     200                                   port.setMinInputSize(buf_size)); 
     201 
     202   buf_size_new = port.getMinInputSize(); 
    201203   CPPUNIT_ASSERT(buf_size == buf_size_new && "Buffer size update failed"); 
    202204 
    …… 
    207209{ 
    208210   vpr::SerialPort port(mSendPortName); 
    209    vpr::Uint8 timeout, timeout_new; 
    210  
    211    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port opening failed", port.open()); 
    212    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Timeout query failed", port.getTimeout(timeout)); 
     211   vpr::Uint8 timeout; 
     212 
     213   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port opening failed", port.open()); 
     214   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Timeout query failed", 
     215                                   timeout = port.getTimeout()); 
    213216 
    214217   timeout++; 
    215    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Timeout update failed", port.setTimeout(timeout)); 
    216  
    217    port.getTimeout(timeout_new); 
     218   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Timeout update failed", 
     219                                   port.setTimeout(timeout)); 
     220 
     221   const vpr::Uint8 timeout_new = port.getTimeout(); 
    218222   CPPUNIT_ASSERT(timeout == timeout_new && "Timeout update failed"); 
    219223 
    …… 
    227231 
    228232   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port opening failed", port.open()); 
    229    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Character size query failed", port.getCharacterSize(orig_size)); 
     233   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Character size query failed", 
     234                                   orig_size = port.getCharacterSize()); 
    230235 
    231236   new_size = (orig_size == vpr::SerialTypes::CS_BITS_8) ? vpr::SerialTypes::CS_BITS_7 
    232237                                                         : vpr::SerialTypes::CS_BITS_8; 
    233238 
    234    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Character size update failed", port.setCharacterSize(new_size)); 
    235  
    236    port.getCharacterSize(mod_size); 
     239   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Character size update failed", 
     240                                   port.setCharacterSize(new_size)); 
     241 
     242   mod_size = port.getCharacterSize(); 
    237243   CPPUNIT_ASSERT(new_size == mod_size && "Character size update failed"); 
    238244 
    239    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Character size reset failed", port.setCharacterSize(orig_size)); 
     245   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Character size reset failed", 
     246                                   port.setCharacterSize(orig_size)); 
    240247 
    241248   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port closing failed", port.close()); 
    …… 
    268275 
    269276   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port opening failed", port.open()); 
    270    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Stop bits query failed", port.getStopBits(orig_bits)); 
     277   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Stop bits query failed", 
     278                                   orig_bits = port.getStopBits()); 
    271279 
    272280   CPPUNIT_ASSERT((orig_bits == 1 || orig_bits == 2) && "Invalid stop bit setting read"); 
    …… 
    274282   new_bits = (orig_bits == 1) ? 2 : 1; 
    275283 
    276    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Stop bits update failed", port.setStopBits(new_bits)); 
    277  
    278    port.getStopBits(mod_bits); 
     284   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Stop bits update failed", 
     285                                   port.setStopBits(new_bits)); 
     286 
     287   mod_bits = port.getStopBits(); 
    279288   CPPUNIT_ASSERT(new_bits == mod_bits && "Stop bits update failed"); 
    280289 
    281    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Stop bits reset failed", port.setStopBits(orig_bits)); 
     290   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Stop bits reset failed", 
     291                                   port.setStopBits(orig_bits)); 
    282292 
    283293   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port closing failed", port.close()); 
    …… 
    467477{ 
    468478   vpr::SerialPort port(mSendPortName); 
    469    vpr::Uint32 orig_baud, mod_baud; 
    470  
    471    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port opening failed", port.open()); 
    472  
    473    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to query input baud rate", port.getInputBaudRate(orig_baud)); 
     479   vpr::Uint32 orig_baud; 
     480 
     481   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port opening failed", port.open()); 
     482 
     483   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to query input baud rate", 
     484                                   orig_baud = port.getInputBaudRate()); 
    474485 
    475486   for ( std::vector<vpr::Uint32>::iterator i = mBaudRates.begin(); 
    …… 
    477488         ++i ) 
    478489   { 
    479       CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to set new baud rate", port.setInputBaudRate(*i)); 
    480       port.getInputBaudRate(mod_baud); 
     490      CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to set new baud rate", 
     491                                      port.setInputBaudRate(*i)); 
     492      const vpr::Uint32 mod_baud = port.getInputBaudRate(); 
    481493      CPPUNIT_ASSERT(mod_baud == *i && "Failed to set new baud rate"); 
    482494   } 
    483495 
    484    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to reset input baud rate", port.setInputBaudRate(orig_baud)); 
     496   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to reset input baud rate", 
     497                                   port.setInputBaudRate(orig_baud)); 
    485498 
    486499   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port closing failed", port.close()); 
    …… 
    490503{ 
    491504   vpr::SerialPort port(mSendPortName); 
    492    vpr::Uint32 orig_baud, mod_baud; 
    493  
    494    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port opening failed", port.open()); 
    495  
    496    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to query output baud rate", port.getOutputBaudRate(orig_baud)); 
     505   vpr::Uint32 orig_baud; 
     506 
     507   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Port opening failed", port.open()); 
     508 
     509   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to query output baud rate", 
     510                                   orig_baud = port.getOutputBaudRate()); 
    497511 
    498512   for ( std::vector<vpr::Uint32>::iterator i = mBaudRates.begin(); 
    …… 
    501515   { 
    502516      CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to set new baud rate", port.setOutputBaudRate(*i)); 
    503       port.getOutputBaudRate(mod_baud); 
     517      const vpr::Uint32 mod_baud = port.getOutputBaudRate(); 
    504518      CPPUNIT_ASSERT(mod_baud == *i && "Failed to set new baud rate"); 
    505519   } 
    …… 
    572586   { 
    573587      std::string buffer; 
    574       vpr::Uint32 bytes_read = 0; 
    575  
    576588      CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to change character size", recv_port.setCharacterSize(vpr::SerialTypes::CS_BITS_8)); 
    577589 
    …… 
    590602 
    591603      CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to read from serial port",  
    592          recv_port.read(buffer, mDataBuffer.size(), bytes_read, vpr::Interval(2, vpr::Interval::Sec))); 
     604         recv_port.read(buffer, mDataBuffer.size(), vpr::Interval(2, vpr::Interval::Sec))); 
    593605      CPPUNIT_ASSERT(mDataBuffer == buffer && "Read wrong string"); 
    594606 
    …… 
    638650      mCondVar.release(); 
    639651 
    640       CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to write", send_port.write(mDataBuffer, mDataBuffer.size(), bytes_written)); 
     652      CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to write", bytes_written = send_port.write(mDataBuffer, mDataBuffer.size())); 
    641653      CPPUNIT_ASSERT(mDataBuffer.size() == bytes_written && "Failed to write all bytes"); 
    642654 

  • juggler/trunk/modules/vapor/test/TestSuite/TestCases/IO/SelectorTest.cpp

    r19550 r19846  
    142142       // use the sock to write (send)... then close it... 
    143143       // Send a message 
    144        CPPUNIT_ASSERT_NO_THROW_MESSAGE("Problem writing in acceptor", sock.write(mMessageValue, mMessageLen, bytes_written)); 
     144       CPPUNIT_ASSERT_NO_THROW_MESSAGE("Problem writing in acceptor", bytes_written = sock.write(mMessageValue, mMessageLen)); 
    145145       // Close the socket 
    146146       CPPUNIT_ASSERT_NO_THROW_MESSAGE("Problem closing accepted socket", sock.close()); 
    …… 
    189189 
    190190      // Recieve data 
    191       CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failure reading data", con_sock.read(data, mMessageLen, bytes_read)); 
     191      CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failure reading data", bytes_read = con_sock.read(data, mMessageLen)); 
    192192      CPPUNIT_ASSERT((bytes_read == mMessageLen) && "Connector recieved message of wrong size" ); 
    193193 
    …… 
    322322            vpr::Uint32 bytes_read; 
    323323             
    324             CPPUNIT_ASSERT_NO_THROW_MESSAGE("Problems reading data", socks[s_idx].read(data, mMessageLen, bytes_read));  
     324            CPPUNIT_ASSERT_NO_THROW_MESSAGE("Problems reading data", bytes_read = socks[s_idx].read(data, mMessageLen));  
    325325            CPPUNIT_ASSERT((bytes_read == mMessageLen) && "Data recieved is of wrong length"); 
    326326         } 
    …… 
    465465         CPPUNIT_ASSERT((mSelectedPorts[j] < sockets.size()));           // Make sure we are in range 
    466466         // Write the data 
    467          CPPUNIT_ASSERT_NO_THROW_MESSAGE("Error writing data on socket", sockets[mSelectedPorts[j]].write(mMessageValue, mMessageLen, bytes_written)); 
     467         CPPUNIT_ASSERT_NO_THROW_MESSAGE("Error writing data on socket", bytes_written = sockets[mSelectedPorts[j]].write(mMessageValue, mMessageLen)); 
    468468         CPPUNIT_ASSERT((mMessageLen == bytes_written) && "Wrong num bytes written"); 
    469469      } 

  • juggler/trunk/modules/vapor/test/TestSuite/TestCases/Socket/NonBlockingSocketsTest.cpp

    r19176 r19846  
    156156void NonBlockingSocketTest::testNonBlockingTransfer_acceptor() 
    157157{ 
    158    vpr::Uint32 bytes_written; 
    159158   vpr::SocketAcceptor acceptor; 
    160159   vpr::SocketStream client_sock; 
    …… 
    206205 
    207206   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to send message to client", 
    208       client_sock.send(mMessage, mMessageLen, bytes_written)); 
     207      client_sock.send(mMessage, mMessageLen)); 
    209208 
    210209   mCondVar.acquire(); 
    …… 
    265264   try 
    266265   { 
    267       con_sock.recv(data, mMessageLen, bytes_read); 
     266      bytes_read = con_sock.recv(data, mMessageLen); 
    268267   } 
    269268   catch (vpr::WouldBlockException& ex) 
    …… 
    370369   // s:    write... 
    371370   std::string message = "Hi Maynard, My leg hurts"; 
    372    vpr::Uint32 bytes_written; 
    373371   CPPUNIT_ASSERT_NO_THROW_MESSAGE( "Problem writing in acceptor", 
    374       spawned_socket.write( message, message.size(), bytes_written )); 
     372      spawned_socket.write( message, message.size() )); 
    375373 
    376374   // s:    write the max size... 
    377375   size_t size; 
    378376   CPPUNIT_ASSERT_NO_THROW_MESSAGE( "couldn't get the max size for sending data with socket", 
    379       spawned_socket.getSendBufferSize( size )); 
     377      size = spawned_socket.getSendBufferSize()); 
    380378   message.resize( size ); 
    381379   CPPUNIT_ASSERT_NO_THROW_MESSAGE( "maxsize test failed", 
    382       spawned_socket.write( message, message.size(), bytes_written )); 
     380      spawned_socket.write( message, message.size() )); 
    383381 
    384382   // block until data is sent 
    …… 
    396394 
    397395   // c:     read 
    398    connector_socket.read( message, message.size(), bytes_written ); 
     396   connector_socket.read( message, message.size() ); 
    399397   CPPUNIT_ASSERT( status.success() && "read test failed" ); 
    400398*/ 
    …… 
    457455      try 
    458456      { 
    459          recv_sock.recvfrom(data, mMessageLen, from_addr, bytes_read); 
     457         bytes_read = recv_sock.recvfrom(data, mMessageLen, from_addr); 
    460458         running = false; 
    461459      } 
    …… 
    487485   vpr::InetAddr remote_addr = vpr::InetAddr::getLocalHost(); 
    488486   vpr::SocketDatagram send_sock; 
    489    vpr::Uint32 bytes; 
    490487 
    491488   remote_addr.setPort(mReceiverPort); 
    …… 
    505502 
    506503   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Failed to send to receiver", 
    507       send_sock.sendto(mMessage, mMessageLen, remote_addr, bytes)); 
     504      send_sock.sendto(mMessage, mMessageLen, remote_addr)); 
    508505 
    509506   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Could not close sender socket", 

  • juggler/trunk/modules/vapor/test/TestSuite/TestCases/Socket/SocketConnectorAcceptorTest.cpp

    r19550 r19846  
    136136      // Send a message 
    137137      CPPUNIT_ASSERT_NO_THROW_MESSAGE("Problem writing in acceptor", 
    138          sock->write(mMessageValue, mMessageLen, bytes_written)); 
     138         bytes_written = sock->write(mMessageValue, mMessageLen)); 
    139139      CPPUNIT_ASSERT((bytes_written == mMessageLen) && "Didn't send entire messag"); 
    140140 
    …… 
    175175 
    176176      // Recieve data 
    177       CPPUNIT_ASSERT_NO_THROW_MESSAGE("Read failed", con_sock.read(data, mMessageLen, bytes_read)); 
     177      CPPUNIT_ASSERT_NO_THROW_MESSAGE("Read failed", bytes_read = con_sock.read(data, mMessageLen)); 
    178178      CPPUNIT_ASSERT((bytes_read == mMessageLen) && "Connector recieved message of wrong size" ); 
    179179 

  • juggler/trunk/modules/vapor/test/TestSuite/TestCases/Socket/SocketCopyConstructorTest.cpp

    r18414 r19846  
    9595   copy_connector = new vpr::SocketStream (connector_socket); 
    9696 
    97    vpr::Uint32 bytes_read; 
    98    CPPUNIT_ASSERT_NO_THROW(copy_connector->read (buffer, 40, bytes_read)); 
     97   CPPUNIT_ASSERT_NO_THROW(copy_connector->read (buffer, 40)); 
    9998   copy_connector->close(); 
    10099 
    …… 
    152151   if (copy_child != NULL) 
    153152   { 
    154       vpr::Uint32 bytes_written; 
    155       copy_child->write(buffer, sizeof(buffer), bytes_written); 
     153      copy_child->write(buffer, sizeof(buffer)); 
    156154      CPPUNIT_ASSERT(copy_child->getType() == child_socket.getType()); 
    157155      CPPUNIT_ASSERT(copy_child->getRemoteAddr() == child_socket.getRemoteAddr()); 

  • juggler/trunk/modules/vapor/test/TestSuite/TestCases/Socket/SocketTest.cpp

    r19550 r19846  
    4444 
    4545      // connect to the acceptor 
    46       CPPUNIT_ASSERT_NO_THROW_MESSAGE("Socket::connect() failed", connector_socket.connect()); 
     46      // XXX: Using the commented out CPPUNIT_ASSERT_NO_THROW_MESSAGE() call 
     47      // below causes a segmentation fault if a vpr::ConnectionRefusedException 
     48      // is thrown. Why?? 
     49      try 
     50      { 
     51         connector_socket.connect(); 
     52      } 
     53      catch (vpr::SocketException& ex) 
     54      { 
     55         break; 
     56      } 
     57//      CPPUNIT_ASSERT_NO_THROW_MESSAGE("Socket::connect() failed", connector_socket.connect()); 
    4758 
    4859      // let acceptor accept it before closing 
    …… 
    161172      vpr::Uint32 amount_read; 
    162173      CPPUNIT_ASSERT_NO_THROW_MESSAGE("readn didn't read", 
    163          connector_socket.readn(&size_of_data, sizeof(int), amount_read)); 
     174         amount_read = connector_socket.readn(&size_of_data, sizeof(int))); 
    164175      CPPUNIT_ASSERT( amount_read == sizeof( int ) && "readn didn't read all" ); 
    165176 
    …… 
    168179      buffer.resize( size_of_data ); 
    169180      CPPUNIT_ASSERT_NO_THROW_MESSAGE("readn didn't read", 
    170        connector_socket.readn(&buffer[0], size_of_data, amount_read)); 
     181       amount_read =connector_socket.readn(&buffer[0], size_of_data)); 
    171182      CPPUNIT_ASSERT( amount_read == size_of_data && "readn didn't read all" ); 
    172183 
    …… 
    216227      vpr::Uint32 size = buffer.size(); 
    217228      CPPUNIT_ASSERT_NO_THROW_MESSAGE("write didn't send", 
    218          child_socket.write( &size, sizeof( int ), amount_sent )); 
     229         amount_sent = child_socket.write(&size, sizeof(int))); 
    219230      CPPUNIT_ASSERT( amount_sent == sizeof( int ) && "write didn't send all" ); 
    220231 
    221232      // send the data... 
    222233      CPPUNIT_ASSERT_NO_THROW_MESSAGE("write didn't send", 
    223          child_socket.write( &buffer[0], buffer.size(), amount_sent)); 
     234         amount_sent = child_socket.write(&buffer[0], buffer.size())); 
    224235      CPPUNIT_ASSERT( amount_sent == buffer.size() && "write didn't send all" ); 
    225236 
    …… 
    398409   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Cannot open sock1", sock1->open()); 
    399410   sock1->setReuseAddr(true); 
     411   CPPUNIT_ASSERT(sock1->getReuseAddr()); 
    400412   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Cannot bind sock1", sock1->bind()); 
    401413 
    …… 
    447459   CPPUNIT_ASSERT_NO_THROW_MESSAGE("server Socket::open() failed", sock1.open()); 
    448460   sock1.setReuseAddr( true ); 
     461   CPPUNIT_ASSERT(sock1.getReuseAddr()); 
    449462   CPPUNIT_ASSERT_NO_THROW_MESSAGE("server Socket::bind() failed", sock1.bind()); 
    450463   CPPUNIT_ASSERT_NO_THROW_MESSAGE("server Socket::listen() failed", sock1.listen()); 
    …… 
    456469   CPPUNIT_ASSERT_NO_THROW_MESSAGE("open(): server restart", sock2.open()); 
    457470   sock2.setReuseAddr( true ); // set the opt in-between for bind() to succeed 
     471   CPPUNIT_ASSERT(sock2.getReuseAddr()); 
    458472   CPPUNIT_ASSERT_NO_THROW_MESSAGE("bind(): server restart", sock2.bind()); 
    459473   //std::cout<<"::::::::: " << result<<"\n"<<std::flush; 
    …… 
    503517      char    buffer[40]; 
    504518      char    buffer2[]="Oops!"; 
    505       vpr::Uint32 amount_read, amount_written; 
     519      vpr::Uint32 amount_read; 
    506520 
    507521      // make a new socket that will connect to port "port" 
    …… 
    530544      if (mReadnFlag == true) 
    531545      { 
    532          connector_socket.readn(buffer, 20, amount_read); 
     546         amount_read = connector_socket.readn(buffer, 20); 
    533547      } 
    534548      else 
    535549      { 
    536          connector_socket.read(buffer, 20, amount_read); 
     550         amount_read = connector_socket.read(buffer, 20); 
    537551      } 
    538552 
    539553      if (amount_read>0) 
    540554      { 
    541          connector_socket.write(buffer, amount_read, amount_written); 
     555         connector_socket.write(buffer, amount_read); 
    542556      } 
    543557      else 
    544558      { 
    545          connector_socket.write(buffer2, sizeof(buffer2), amount_written); 
     559         connector_socket.write(buffer2, sizeof(buffer2)); 
    546560      } 
    547561 
    …… 
    566580   char  buffer1[]="Hello, there!"; 
    567581   char  buffer2[]="Hello"; 
    568    vpr::Uint32 amount_read (0), amount_written; 
     582   vpr::Uint32 amount_read (0); 
    569583   vpr::InetAddr local_addr; 
    570584 
    …… 
    613627      vpr::System::msleep(50); 
    614628 
    615       child_socket.write(buffer1, sizeof(buffer1), amount_written); 
     629      child_socket.write(buffer1, sizeof(buffer1)); 
    616630 
    617631      vpr::System::msleep(5); 
    618632 
    619       child_socket.write(buffer2, sizeof(buffer2), amount_written); 
     633      child_socket.write(buffer2, sizeof(buffer2)); 
    620634 
    621635      child_socket.setBlocking(false); 
    622       child_socket.read(buffer, 40, amount_read); 
     636      amount_read = child_socket.read(buffer, 40); 
    623637      child_socket.setBlocking(true); 
    624638 
    …… 
    751765      CPPUNIT_ASSERT_NO_THROW( sock->connect() ); 
    752766      { 
    753          vpr::Uint32 bytes, bytes_written; 
    754          sock->read(buffer1, 40, bytes); 
    755       //sock->write(buffer2, sizeof(buffer2), bytes_written); 
    756          sock->write(buffer1, bytes, bytes_written); 
     767         const vpr::Uint32 bytes = sock->read(buffer1, 40); 
     768      //sock->write(buffer2, sizeof(buffer2)); 
     769         sock->write(buffer1, bytes); 
    757770         mItemProtectionMutex.acquire(); 
    758771         mClientCounter++; 
    …… 
    768781   char buffer1[] = "Hello there!"; 
    769782   char buffer2[40]; 
    770    vpr::Uint32 bytes, bytes_written; 
     783   vpr::Uint32 bytes; 
    771784 
    772785   vpr::SocketStream* ss_sock; 
    773786   ss_sock=tArg->mSock; 
    774787   //send a string to client 
    775    ss_sock->write(buffer1, sizeof(buffer1), bytes_written); 
     788   ss_sock->write(buffer1, sizeof(buffer1)); 
    776789   //receive a string from client 
    777    ss_sock->read(buffer2,40, bytes); 
     790   bytes = ss_sock->read(buffer2,40); 
    778791   CPPUNIT_ASSERT(bytes != 0); 
    779792   long compareString=strcmp(buffer1,buffer2); 
    …… 
    797810   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Client socket open failed", client_sock.open()); 
    798811   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Client could not connect", client_sock.connect()); 
    799    vpr::Uint32 bytes; 
    800    client_sock.readn(buffer, sizeof(buffer), bytes); 
     812   const vpr::Uint32 bytes = client_sock.readn(buffer, sizeof(buffer)); 
    801813   CPPUNIT_ASSERT((bytes == sizeof(buffer)) && "readn didn't read enough!"); 
    802814   client_sock.close(); 
    …… 
    813825   const unsigned int bytes_to_send = 20; 
    814826   const unsigned int pkt_size = 5; 
    815    vpr::Uint32 bytes; 
    816827   char buffer[pkt_size]; 
    817828 
    …… 
    839850      unsigned to_send = pkt_size; 
    840851      if( (bytes_to_send-bytes_sent) < to_send) 
    841       { to_send = bytes_to_send-bytes_sent; } 
    842  
    843       client_sock.write(buffer, pkt_size, bytes); 
    844       bytes_sent += bytes; 
     852      { 
     853         to_send = bytes_to_send - bytes_sent; 
     854      } 
     855 
     856      bytes_sent += client_sock.write(buffer, pkt_size); 
    845857   } 
    846858 
    …… 
    977989 
    978990   CPPUNIT_ASSERT_THROW_MESSAGE("Socket is disconnected", 
    979                                 client_sock.recv((void*)temp_buffer, 50, bytes_handled), 
     991                                bytes_handled = client_sock.recv((void*)temp_buffer, 50), 
    980992                                vpr::SocketException); 
    981    CPPUNIT_ASSERT(bytes_handled == 0); 
     993   // The above will result in an exceptin being thrown, so bytes_handled 
     994   // will not be assigned a value. 
     995   CPPUNIT_ASSERT(bytes_handled == 80); 
    982996 
    983997   //CPPUNIT_ASSERT(!client_sock.isConnected() && "Should not be connected after read"); 
    …… 
    9861000   /* 
    9871001   CPPUNIT_ASSERT_THROW_MESSAGE("Socket is disconnected", 
    988                                 client_sock.send((void*)temp_buffer, 50, bytes_handled), 
     1002                                bytes_handled = client_sock.send((void*)temp_buffer, 50), 
    9891003                                vpr::IOException); 
    9901004                                */ 
    991    client_sock.send((void*)temp_buffer, 50, bytes_handled); 
     1005   bytes_handled = client_sock.send((void*)temp_buffer, 50); 
    9921006 
    9931007   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Could not close acceptor side of client socket", client_sock.close()); 
    9941008 
    995    CPPUNIT_ASSERT(NULL == client_sock.getHandle() && "Socket handle should be NULL"); 
    9961009   CPPUNIT_ASSERT( !client_sock.isConnected() && "Should be fully disconnected after read and write"); 
    997  
    998    /* 
    999    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Could not close acceptor side of client socket", client_sock.close()); 
    1000    */ 
    10011010 
    10021011   CPPUNIT_ASSERT_NO_THROW_MESSAGE("Could not close acceptor", acceptor.close()); 

  • juggler/trunk/modules/vapor/vpr/IO/BlockIO.cpp

    r19729