1 
// SPDX-License-Identifier: BSD-2-Clause
2 
/*
3 
 * Copyright © The libcoap-rs Contributors, all rights reserved.
4 
 * This file is part of the libcoap-rs project, see the README file for
5 
 * general information on this project and the NOTICE.md and LICENSE files
6 
 * for information regarding copyright ownership and terms of use.
7 
 *
8 
 * tests/dtls_client_server_test.rs - Tests for UDP clients+servers.
9 
 */
10 

            

        

            

                11
            

            

                
            

            

                
use std::time::Duration;

            

        

            

                12
            

            

                
            

            

                

            

        

            

                13
            

            

                
            

            

                
use libcoap_rs::{

            

        

            

                14
            

            

                
            

            

                
    message::CoapMessageCommon,

            

        

            

                15
            

            

                
            

            

                
    protocol::{CoapMessageCode, CoapResponseCode},

            

        

            

                16
            

            

                
            

            

                
    session::{CoapClientSession, CoapSessionCommon},

            

        

            

                17
            

            

                
            

            

                
    CoapContext,

            

        

            

                18
            

            

                
            

            

                
};

            

        

            

                19
            

            

                
            

            

                

            

        

            

                20
            

            

                
            

            

                
mod common;

            

        

            

                21
            

            

                
            

            

                

            

        

            

                22
            

            

                
            

            

                
#[test]

            

        

            

                23
            

            

                4
            

            

                
pub fn basic_client_server_request() {

            

        

            

                24
            

            

                4
            

            

                
    let server_address = common::get_unused_server_addr();

            

        

            

                25
            

            

                4
            

            

                

            

        

            

                26
            

            

                4
            

            

                
    let server_handle = common::spawn_test_server(move |mut context| {

            

        

            

                27
            

            

                4
            

            

                
        context.add_endpoint_udp(server_address).unwrap();

            

        

            

                28
            

            

                4
            

            

                
        context

            

        

            

                29
            

            

                4
            

            

                
    });

            

        

            

                30
            

            

                4
            

            

                

            

        

            

                31
            

            

                4
            

            

                
    let mut context = CoapContext::new().unwrap();

            

        

            

                32
            

            

                4
            

            

                
    let session = CoapClientSession::connect_udp(&mut context, server_address).unwrap();

            

        

            

                33
            

            

                4
            

            

                

            

        

            

                34
            

            

                4
            

            

                
    let request = common::gen_test_request();

            

        

            

                35
            

            

                4
            

            

                
    let req_handle = session.send_request(request).unwrap();

            

        

            

                36
            

            

                
            

            

                
    loop {

            

        

            

                37
            

            

                4
            

            

                
        assert!(context.do_io(Some(Duration::from_secs(10))).expect("error during IO") <= Duration::from_secs(10));

            

        

            

                38
            

            

                4
            

            

                
        for response in session.poll_handle(&req_handle) {

            

        

            

                39
            

            

                4
            

            

                
            assert_eq!(response.code(), CoapMessageCode::Response(CoapResponseCode::Content));

            

        

            

                40
            

            

                4
            

            

                
            assert_eq!(response.data().unwrap().as_ref(), "Hello World!".as_bytes());

            

        

            

                41
            

            

                4
            

            

                
            server_handle.join().unwrap();

            

        

            

                42
            

            

                4
            

            

                
            return;

            

        

            

                43
            

            

                4
            

            

                
        }

            

        

            

                44
            

            

                4
            

            

                
    }

            

        

            

                45
            

            

                4
            

            

                
}