libtins/tests/src/dhcpv6.cpp

#include <gtest/gtest.h>
#include <cstring>
#include <string>
#include <stdint.h>
#include "dhcpv6.h"

using namespace Tins;

class DHCPv6Test : public testing::Test {
public:
    static const uint8_t expected_packet[];

    void test_equals(const DHCPv6 &dhcp1, const DHCPv6 &dhcp2);
};

const uint8_t DHCPv6Test::expected_packet[] = {
    '\x01', '\xe8', '(', '\xb9', '\x00', '\x01', '\x00', '\n', '\x00', 
    '\x03', '\x00', '\x01', '\x00', '\x01', '\x02', '\x03', '\x04', 
    '\x05', '\x00', '\x03', '\x00', '\x0c', '\x00', '\x00', '\x00', 
    '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', 
    '\x00', '\x00', '\x08', '\x00', '\x02', '\x00', '\x00', '\x00',
    '\x06', '\x00', '\x02', '\x00', '\x03'
};

TEST_F(DHCPv6Test, DefaultConstructor) {
    DHCPv6 dhcp;
    EXPECT_EQ(0, (int)dhcp.msg_type());
    EXPECT_EQ(0, dhcp.hop_count());
    EXPECT_EQ(0, dhcp.transaction_id());
}

TEST_F(DHCPv6Test, ConstructorFromBuffer) {
    DHCPv6 dhcp(expected_packet, sizeof(expected_packet));
    EXPECT_EQ(DHCPv6::SOLICIT, dhcp.msg_type());
    EXPECT_EQ(0xe828b9, dhcp.transaction_id());
    EXPECT_TRUE(dhcp.search_option(DHCPv6::CLIENTID));
    EXPECT_TRUE(dhcp.search_option(DHCPv6::IA_NA));
    EXPECT_TRUE(dhcp.search_option(DHCPv6::ELAPSED_TIME));
    EXPECT_TRUE(dhcp.search_option(DHCPv6::OPTION_REQUEST));
    EXPECT_FALSE(dhcp.search_option(DHCPv6::SERVERID));
}

TEST_F(DHCPv6Test, Serialize) {
    DHCPv6 dhcp(expected_packet, sizeof(expected_packet));
    DHCPv6::serialization_type buffer = dhcp.serialize();
    ASSERT_EQ(sizeof(expected_packet), buffer.size());
    EXPECT_EQ(
        DHCPv6::serialization_type(expected_packet, expected_packet + sizeof(expected_packet)),
        buffer
    );
}

TEST_F(DHCPv6Test, MessageType) {
    DHCPv6 dhcp;
    dhcp.msg_type(DHCPv6::SOLICIT);
    EXPECT_EQ(DHCPv6::SOLICIT, dhcp.msg_type());
}

TEST_F(DHCPv6Test, HopCount) {
    DHCPv6 dhcp;
    dhcp.hop_count(0x8a);
    EXPECT_EQ(0x8a, dhcp.hop_count());
}

TEST_F(DHCPv6Test, TransactionId) {
    DHCPv6 dhcp;
    dhcp.transaction_id(0x8af2ad);
    EXPECT_EQ(0x8af2ad, dhcp.transaction_id());
}

// Options

TEST_F(DHCPv6Test, IA_NA) {
    DHCPv6 dhcp;
    DHCPv6::ia_na_type data, output;
    data.id = 0x9283f78a;
    data.t1 = 0xaf235212;
    data.t2 = 0x9a8293fa;
    data.options.push_back(0);
    data.options.push_back(1);
    data.options.push_back(2);
    dhcp.ia_na(data);
    output = dhcp.ia_na();
    
    EXPECT_EQ(data.id, output.id);
    EXPECT_EQ(data.t1, output.t1);
    EXPECT_EQ(data.t2, output.t2);
    EXPECT_EQ(data.options, output.options);
}

TEST_F(DHCPv6Test, IA_TA) {
    DHCPv6 dhcp;
    DHCPv6::ia_ta_type data, output;
    data.id = 0x9283f78a;
    data.options.push_back(0);
    data.options.push_back(1);
    data.options.push_back(2);
    dhcp.ia_ta(data);
    output = dhcp.ia_ta();
    
    EXPECT_EQ(data.id, output.id);
    EXPECT_EQ(data.options, output.options);
}

TEST_F(DHCPv6Test, IA_Address) {
    DHCPv6 dhcp;
    DHCPv6::ia_address_type data, output;
    data.address = "fe00:feaa::1";
    data.preferred_lifetime = 0x9283f78a;
    data.valid_lifetime = 0x938fda32;
    data.options.push_back(0);
    data.options.push_back(1);
    data.options.push_back(2);
    dhcp.ia_address(data);
    output = dhcp.ia_address();
    
    EXPECT_EQ(data.address, output.address);
    EXPECT_EQ(data.preferred_lifetime, output.preferred_lifetime);
    EXPECT_EQ(data.valid_lifetime, output.valid_lifetime);
    EXPECT_EQ(data.options, output.options);
}

TEST_F(DHCPv6Test, OptionRequest) {
    DHCPv6 dhcp;
    DHCPv6::option_request_type data, output;
    data.push_back(DHCPv6::IA_ADDR);
    data.push_back(DHCPv6::IA_NA);
    
    dhcp.option_request(data);
    output = dhcp.option_request();
    
    EXPECT_EQ(data, output);
}

TEST_F(DHCPv6Test, Preference) {
    DHCPv6 dhcp;
    dhcp.preference(0x8a);
    EXPECT_EQ(0x8a, dhcp.preference());
}

TEST_F(DHCPv6Test, ElapsedTime) {
    DHCPv6 dhcp;
    dhcp.elapsed_time(0x8a2f);
    EXPECT_EQ(0x8a2f, dhcp.elapsed_time());
}

TEST_F(DHCPv6Test, RelayMessage) {
    DHCPv6 dhcp;
    DHCPv6::relay_msg_type data, output;
    data.push_back(1);
    data.push_back(156);
    data.push_back(12);
    
    dhcp.relay_message(data);
    output = dhcp.relay_message();
    
    EXPECT_EQ(data, output);
}

TEST_F(DHCPv6Test, Authentication) {
    DHCPv6 dhcp;
    DHCPv6::authentication_type data, output;
    data.protocol = 0x92;
    data.algorithm = 0x8f;
    data.rdm = 0xa1;
    data.replay_detection = 0x78ad6d5290398df7;
    data.auth_info.push_back(0);
    data.auth_info.push_back(1);
    data.auth_info.push_back(2);
    dhcp.authentication(data);
    output = dhcp.authentication();
    
    EXPECT_EQ(data.protocol, output.protocol);
    EXPECT_EQ(data.algorithm, output.algorithm);
    EXPECT_EQ(data.rdm, output.rdm);
    EXPECT_EQ(data.replay_detection, output.replay_detection);
    EXPECT_EQ(data.auth_info, output.auth_info);
}

TEST_F(DHCPv6Test, ServerUnicast) {
    const IPv6Address addr("fe00:0a9d:dd23::1");
    DHCPv6 dhcp;
    dhcp.server_unicast(addr);
    EXPECT_EQ(addr, dhcp.server_unicast());
}

TEST_F(DHCPv6Test, StatusCode) {
    DHCPv6 dhcp;
    DHCPv6::status_code_type data(0x72, "libtins, mah frend"), output;
    dhcp.status_code(data);
    output = dhcp.status_code();
    EXPECT_EQ(data.code, output.code);
    EXPECT_EQ(data.message, output.message);
}

TEST_F(DHCPv6Test, RapidCommit) {
    DHCPv6 dhcp;
    dhcp.rapid_commit();
    EXPECT_EQ(true, dhcp.has_rapid_commit());
}

TEST_F(DHCPv6Test, UserClass) {
    DHCPv6 dhcp;
    DHCPv6::user_class_type data, output;
    DHCPv6::class_option_data_type user_data;
    user_data.push_back(22);
    user_data.push_back(176);
    data.push_back(user_data);
    
    user_data.push_back(99);
    user_data.push_back(231);
    data.push_back(user_data);
    
    dhcp.user_class(data);
    output = dhcp.user_class();
    
    EXPECT_EQ(data, output);
}

TEST_F(DHCPv6Test, VendorClass) {
    DHCPv6 dhcp;
    DHCPv6::vendor_class_type data(15), output;
    DHCPv6::class_option_data_type user_data;
    user_data.push_back(22);
    user_data.push_back(176);
    data.vendor_class_data.push_back(user_data);
    
    user_data.push_back(99);
    user_data.push_back(231);
    data.vendor_class_data.push_back(user_data);
    
    dhcp.vendor_class(data);
    output = dhcp.vendor_class();
    
    EXPECT_EQ(data.enterprise_number, output.enterprise_number);
    EXPECT_EQ(data.vendor_class_data, output.vendor_class_data);
}

TEST_F(DHCPv6Test, VendorInfo) {
    DHCPv6 dhcp;
    DHCPv6::vendor_info_type data(0x72988fad), output;
    data.data.push_back(22);
    data.data.push_back(176);
    data.data.push_back(99);
    data.data.push_back(231);
    
    dhcp.vendor_info(data);
    output = dhcp.vendor_info();
    
    EXPECT_EQ(data.enterprise_number, output.enterprise_number);
    EXPECT_EQ(data.data, output.data);
}

TEST_F(DHCPv6Test, InterfaceID) {
    DHCPv6 dhcp;
    DHCPv6::interface_id_type data, output;
    data.push_back(1);
    data.push_back(156);
    data.push_back(12);
    
    dhcp.interface_id(data);
    output = dhcp.interface_id();
    
    EXPECT_EQ(data, output);
}

TEST_F(DHCPv6Test, ReconfigureMsg) {
    DHCPv6 dhcp;
    dhcp.reconfigure_msg(0x8a);
    EXPECT_EQ(0x8a, dhcp.reconfigure_msg());
}

TEST_F(DHCPv6Test, ReconfigureAccept) {
    DHCPv6 dhcp;
    dhcp.reconfigure_accept();
    EXPECT_EQ(true, dhcp.has_reconfigure_accept());
}