FPS 0.0.3

#[macro_use]
extern crate fps;
use fps::n::packet::*;
use fps::n::*;
use std::cmp::Ordering::*;

extern "C" {
    fn c_extern_test(test_no: i32) -> i32;
}

fn rust_c_extern_test(test_no: i32) -> bool {
    unsafe { c_extern_test(test_no) == 0 }
}

#[test]
fn c_extern_test1() {
    let ret = rust_c_extern_test(1);
    assert!(ret);
}

#[test]
fn c_extern_test2() {
    let ret = rust_c_extern_test(2);
    assert!(ret);
}

#[test]
fn c_extern_test3() {
    let ret = rust_c_extern_test(3);
    assert!(ret);
}

// IPv4 TCP SYN packet
fn prepare_packet1<'a>(input: &'a mut Buffer) -> Field<'a> {
    let content: &[Byte] = &[0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC,
                             0xBC, 0x08, 0x00, 0x45, 0x00, 0x00, 0x28, 0x00, 0x00, 0x40, 0x00,
                             0x40, 0x06, 0x6F, 0x1D, 0xC0, 0xA8, 0x00, 0x07, 0x0A, 0x00, 0x01,
                             0x04, 0x56, 0xCE, 0x30, 0x39, 0xFF, 0x08, 0x28, 0xB7, 0x00, 0x00,
                             0x00, 0x00, 0x50, 0x02, 0xC8, 0x00, 0x6D, 0x67, 0x00, 0x00];

    let mut buffer = &mut input[0..content.len()];
    move_field(content, buffer);
    buffer
}

// IPv4 HTTP packet 200 OK
fn prepare_packet2<'a>(input: &'a mut Buffer) -> Field<'a> {
    let content: &[Byte] = &[0x00, 0x0B, 0xDB, 0x4D, 0x6A, 0x3B, 0x00, 0x16, 0x60, 0x57, 0xE2,
                             0x06, 0x08, 0x00, 0x45, 0x00, 0x00, 0x28, 0x41, 0x58, 0x40, 0x00,
                             0x7E, 0x06, 0x22, 0x08, 0x0A, 0x03, 0x01, 0x5C, 0x0A, 0x2E, 0x83,
                             0xE3, 0x1F, 0x90, 0x08, 0x42, 0xC8, 0xBE, 0x16, 0x87, 0x80, 0xC6,
                             0x73, 0x7F, 0x50, 0x11, 0xFA, 0xF0, 0x20, 0x15, 0x00, 0x00, 0x00,
                             0x00, 0x00, 0x00, 0x00, 0x00];

    let mut buffer = &mut input[0..content.len()];
    move_field(content, buffer);
    buffer
}

// IPv4 UDP packet
fn prepare_packet3<'a>(input: &'a mut Buffer) -> Field<'a> {
    let content: &[Byte] = &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x30, 0x96, 0x05, 0x28,
                             0x38, 0x08, 0x00, 0x45, 0xC0, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
                             0x01, 0x11, 0xAC, 0xFC, 0x0A, 0x01, 0x02, 0x01, 0xFF, 0xFF, 0xFF,
                             0xFF, 0x02, 0xC7, 0x02, 0xC7, 0x00, 0x1C, 0xC9, 0xFC, 0x00, 0x01,
                             0x00, 0x10, 0x0A, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x0E, 0x0F,
                             0x03, 0x00, 0x04, 0x0A, 0x01, 0x00, 0x01];

    let mut buffer = &mut input[0..content.len()];
    move_field(content, buffer);
    buffer
}

// IPv6 HTTP GET packet
fn prepare_packet4<'a>(input: &'a mut Buffer) -> Field<'a> {
    let content: &[Byte] = &[0x00, 0x11, 0x25, 0x13, 0xEC, 0xDD, 0x00, 0xE0, 0x81, 0x4C, 0x26,
                             0xCC, 0x86, 0xDD, 0x60, 0x00, 0x00, 0x00, 0x00, 0xCB, 0x00, 0x40,
                             0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                             0x00, 0x00, 0x00, 0x01, 0x33, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00,
                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x3C,
                             0x00, 0x0F, 0x02, 0x00, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0F, 0x02,
                             0x00, 0x00, 0x01, 0x00, 0xD9, 0x41, 0x00, 0x50, 0x6E, 0x90, 0x91,
                             0x04, 0x70, 0xC7, 0x07, 0xC6, 0x80, 0x18, 0x00, 0x2D, 0x30, 0x50,
                             0x00, 0x00, 0x01, 0x01, 0x08, 0x0A, 0x5A, 0x1E, 0xDC, 0x06, 0x00,
                             0xD0, 0x72, 0x0D, 0x47, 0x45, 0x54, 0x20, 0x2F, 0x20, 0x48, 0x54,
                             0x54, 0x50, 0x2F, 0x31, 0x2E, 0x31, 0x0D, 0x0A, 0x55, 0x73, 0x65,
                             0x72, 0x2D, 0x41, 0x67, 0x65, 0x6E, 0x74, 0x3A, 0x20, 0x63, 0x75,
                             0x72, 0x6C, 0x2F, 0x37, 0x2E, 0x31, 0x35, 0x2E, 0x35, 0x20, 0x28,
                             0x78, 0x38, 0x36, 0x5F, 0x36, 0x34, 0x2D, 0x72, 0x65, 0x64, 0x68,
                             0x61, 0x74, 0x2D, 0x6C, 0x69, 0x6E, 0x75, 0x78, 0x2D, 0x67, 0x6E,
                             0x75, 0x29, 0x20, 0x6C, 0x69, 0x62, 0x63, 0x75, 0x72, 0x6C, 0x2F,
                             0x37, 0x2E, 0x31, 0x35, 0x2E, 0x35, 0x20, 0x4F, 0x70, 0x65, 0x6E,
                             0x53, 0x53, 0x4C, 0x2F, 0x30, 0x2E, 0x39, 0x2E, 0x38, 0x62, 0x20,
                             0x7A, 0x6C, 0x69, 0x62, 0x2F, 0x31, 0x2E, 0x32, 0x2E, 0x33, 0x20,
                             0x6C, 0x69, 0x62, 0x69, 0x64, 0x6E, 0x2F, 0x30, 0x2E, 0x36, 0x2E,
                             0x35, 0x0D, 0x0A, 0x48, 0x6F, 0x73, 0x74, 0x3A, 0x20, 0x5B, 0x31,
                             0x30, 0x30, 0x31, 0x3A, 0x3A, 0x31, 0x34, 0x30, 0x5D, 0x0D, 0x0A,
                             0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3A, 0x20, 0x2A, 0x2F, 0x2A,
                             0x0D, 0x0A, 0x0D, 0x0A];

    let mut buffer = &mut input[0..content.len()];
    move_field(content, buffer);
    buffer
}

// IPv6 UDP packet
fn prepare_packet5<'a>(input: &'a mut Buffer) -> Field<'a> {
    let content: &[Byte] = &[0x33, 0x33, 0x00, 0x01, 0x00, 0x06, 0x00, 0x0A, 0xE6, 0xAE, 0xA5,
                             0xA2, 0x86, 0xDD, 0x60, 0x00, 0x00, 0x00, 0x00, 0x18, 0x11, 0x01,
                             0xFE, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0A, 0xE6,
                             0xFF, 0xFE, 0xAE, 0xA5, 0xA2, 0xFF, 0x02, 0x00, 0x00, 0x00, 0x00,
                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x06, 0x1A,
                             0x29, 0x1A, 0x29, 0x00, 0x18, 0x33, 0x0B, 0x2A, 0x02, 0x00, 0x0C,
                             0x04, 0x06, 0x00, 0x00, 0xCE, 0x94, 0x07, 0xD0, 0x09, 0x02, 0x00,
                             0x00];

    let mut buffer = &mut input[0..content.len()];
    move_field(content, buffer);
    buffer
}

#[test]
fn test_read_u8() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let read_val = packet.read_u8(24);

    assert_eq!(read_val, 0x6F);
}

#[test]
fn test_read_u16() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let read_val = packet.read_u16(24);

    assert_eq!(read_val, 0x6F1D);
}

#[test]
fn test_read_u32() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let read_val = packet.read_u32(24);

    assert_eq!(read_val, 0x6F1DC0A8);
}

#[test]
fn test_read_u64() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let read_val = packet.read_u64(24);

    assert_eq!(read_val, 0x6F1DC0A800070A00);
}

#[test]
fn test_read_u8_unaligned() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let read_val = packet.read_u8(25);

    assert_eq!(read_val, 0x1D);
}

#[test]
fn test_read_u16_unaligned() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let read_val = packet.read_u16(25);

    assert_eq!(read_val, 0x1DC0);
}

#[test]
fn test_read_u32_unaligned() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let read_val = packet.read_u32(25);

    assert_eq!(read_val, 0x1DC0A800);
}

#[test]
fn test_read_u64_unaligned() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let read_val = packet.read_u64(25);

    assert_eq!(read_val, 0x1DC0A800070A0001);
}

#[test]
fn test_write_u8() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.write_u8(24, 0xEE);
    let read_val = packet.read_u8(24);

    assert_eq!(read_val, 0xEE);
}

#[test]
fn test_write_u16() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.write_u16(24, 0xEEEE);
    let read_val = packet.read_u16(24);

    assert_eq!(read_val, 0xEEEE);
}

#[test]
fn test_write_u32() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.write_u32(24, 0xEEEEEEEE);
    let read_val = packet.read_u32(24);

    assert_eq!(read_val, 0xEEEEEEEE);
}

#[test]
fn test_write_u64() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.write_u64(24, 0xEEEEEEEEEEEEEEEE);
    let read_val = packet.read_u64(24);

    assert_eq!(read_val, 0xEEEEEEEEEEEEEEEE);
}

#[test]
fn test_write_u8_unaligned() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.write_u8(25, 0xEE);
    let read_val = packet.read_u8(25);

    assert_eq!(read_val, 0xEE);
}

#[test]
fn test_write_u16_unaligned() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.write_u16(25, 0xEEEE);
    let read_val = packet.read_u16(25);

    assert_eq!(read_val, 0xEEEE);
}

#[test]
fn test_write_u32_unaligned() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.write_u32(25, 0xEEEEEEEE);
    let read_val = packet.read_u32(25);

    assert_eq!(read_val, 0xEEEEEEEE);
}

#[test]
fn test_write_u64_unaligned() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.write_u64(25, 0xEEEEEEEEEEEEEEEE);
    let read_val = packet.read_u64(25);

    assert_eq!(read_val, 0xEEEEEEEEEEEEEEEE);
}

#[test]
fn test_right_packet() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let read_val = packet.read_u64(24);
    assert_eq!(read_val, 0x6F1DC0A800070A00);

    let expect_dst = &[0xCDu8; 6];
    let expect_src = &[0xBCu8; 6];
    let expect_proto = 0x0800u16;

    let (packet, dst_addr) = packet.right_packet(6);
    assert_eq!(dst_addr, expect_dst);

    let (packet, src_addr) = packet.right_packet(6);
    assert_eq!(src_addr, expect_src);

    let proto = packet.read_u16(0);
    assert_eq!(proto, expect_proto);

    let read_val = packet.read_u64(24);
    assert_eq!(read_val, 0x3039FF0828B70000);
}

#[test]
fn test_right_strip_packet() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let read_val = packet.read_u64(24);
    assert_eq!(read_val, 0x6F1DC0A800070A00);

    let packet = packet.right_strip(6).right_strip(6);

    let read_val = packet.read_u64(24);
    assert_eq!(read_val, 0x3039FF0828B70000);
}

#[test]
fn test_packet_len() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);
    let packet = Packet::new(buffer);

    let len = packet.len();
    assert_eq!(len, 54);
}

#[test]
fn test_packet_len_with_right_strip() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);
    let mut packet = Packet::new(buffer);

    let len = packet.len();
    assert_eq!(len, 54);

    for i in 1..(len + 1) {
        packet = packet.right_strip(1);
        let expect = len - i;
        let current = packet.len();
        assert_eq!(current, expect);
    }
}

#[test]
fn test_context_string() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.context.set_string("test_field_hello", "Hello");
    packet.context.set_string("test_field_bye", "Bye");
    let string_true = packet.context.get_string("test_field_hello");
    let string_false = packet.context.get_string("test_field_bye");
    assert_eq!(string_true, "Hello");
    assert_eq!(string_false, "Bye");

    let current_len = packet.len();

    for _ in 0..current_len {
        packet = packet.right_strip(1);
        let string_true = packet.context.get_string("test_field_hello");
        let string_false = packet.context.get_string("test_field_bye");
        assert_eq!(string_true, "Hello");
        assert_eq!(string_false, "Bye");
    }
}

#[test]
fn test_context_bool() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.context.set_bool("test_field_true", true);
    packet.context.set_bool("test_field_false", false);
    let bool_true = packet.context.get_bool("test_field_true");
    let bool_false = packet.context.get_bool("test_field_false");
    assert_eq!(bool_true, true);
    assert_eq!(bool_false, false);

    let current_len = packet.len();

    for _ in 0..current_len {
        packet = packet.right_strip(1);
        let bool_true = packet.context.get_bool("test_field_true");
        let bool_false = packet.context.get_bool("test_field_false");
        assert_eq!(bool_true, true);
        assert_eq!(bool_false, false);
    }
}

#[test]
fn test_context_u8() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.context.set_u8("test_field_u8", 17);
    let u8_field = packet.context.get_u8("test_field_u8");
    assert_eq!(u8_field, 17);

    let current_len = packet.len();

    for _ in 0..current_len {
        packet = packet.right_strip(1);
        let u8_field = packet.context.get_u8("test_field_u8");
        assert_eq!(u8_field, 17);
    }
}

#[test]
fn test_context_u16() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.context.set_u16("test_field_u16", 17);
    let u16_field = packet.context.get_u16("test_field_u16");
    assert_eq!(u16_field, 17);

    let current_len = packet.len();

    for _ in 0..current_len {
        packet = packet.right_strip(1);
        let u16_field = packet.context.get_u16("test_field_u16");
        assert_eq!(u16_field, 17);
    }
}

#[test]
fn test_context_u32() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.context.set_u32("test_field_u32", 17);
    let u32_field = packet.context.get_u32("test_field_u32");
    assert_eq!(u32_field, 17);

    let current_len = packet.len();

    for _ in 0..current_len {
        packet = packet.right_strip(1);
        let u32_field = packet.context.get_u32("test_field_u32");
        assert_eq!(u32_field, 17);
    }
}

#[test]
fn test_context_u64() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let mut packet = Packet::new(buffer);
    packet.context.set_u64("test_field_u64", 17);
    let u64_field = packet.context.get_u64("test_field_u64");
    assert_eq!(u64_field, 17);

    let current_len = packet.len();

    for _ in 0..current_len {
        packet = packet.right_strip(1);
        let u64_field = packet.context.get_u64("test_field_u64");
        assert_eq!(u64_field, 17);
    }
}

#[test]
fn test_context_field() {
    let mut temp_buffer = ZERO_BUFFER;
    let expect_ether_dst: &[u8; 6] = &[0xCDu8; 6];
    let expect_ether_src: &[u8; 6] = &[0xBCu8; 6];
    let expect_ip_src: &[u8; 4] = &[0xC0, 0xA8, 0x00, 0x07];
    let expect_ip_dst: &[u8; 4] = &[0x0A, 0x00, 0x01, 0x04];

    let buffer = prepare_packet1(&mut temp_buffer);

    {
        let packet = Packet::new(buffer);
        let (mut packet, mut ether_dst) = packet.right_packet(6);
        packet.context.set_field("test_field_ether_dst", ether_dst);

        let (mut packet, mut ether_src) = packet.right_packet(6);
        packet.context.set_field("test_field_ether_src", ether_src);
        packet = packet.right_strip(2);
        packet = packet.right_strip(12);

        let (mut packet, mut ip_src) = packet.right_packet(4);
        packet.context.set_field("test_field_ip_src", ip_src);
        let (mut packet, mut ip_dst) = packet.right_packet(4);
        packet.context.set_field("test_field_ip_dst", ip_dst);

        {
            let ether_dst = packet.context.get_field("test_field_ether_dst");
            let ether_src = packet.context.get_field("test_field_ether_src");
            let ip_src = packet.context.get_field("test_field_ip_src");
            let ip_dst = packet.context.get_field("test_field_ip_dst");

            assert_eq!(compare_field(expect_ether_dst, ether_dst), Equal);
            assert_eq!(compare_field(expect_ether_src, ether_src), Equal);
            assert_eq!(compare_field(expect_ip_src, ip_src), Equal);
            assert_eq!(compare_field(expect_ip_dst, ip_dst), Equal);
        }

        let mut ether_dst = packet.context.take_field("test_field_ether_dst");
        let mut ether_src = packet.context.take_field("test_field_ether_src");
        let mut ip_src = packet.context.take_field("test_field_ip_src");
        let mut ip_dst = packet.context.take_field("test_field_ip_dst");

        let mut ether_temp = [0u8; 6];
        let mut ip_temp = [0u8; 4];
        move_field(ether_dst, &mut ether_temp);
        move_field(ether_src, ether_dst);
        move_field(&ether_temp, ether_src);

        move_field(ip_dst, &mut ip_temp);
        move_field(ip_src, ip_dst);
        move_field(&ip_temp, ip_src);
    }
    {
        let packet = Packet::new(buffer);
        let (mut packet, mut ether_dst) = packet.right_packet(6);
        packet.context.set_field("test_field_ether_dst2", ether_dst);

        let (mut packet, mut ether_src) = packet.right_packet(6);
        packet.context.set_field("test_field_ether_src2", ether_src);
        packet = packet.right_strip(2);
        packet = packet.right_strip(12);

        let (mut packet, mut ip_src) = packet.right_packet(4);
        packet.context.set_field("test_field_ip_src2", ip_src);
        let (mut packet, mut ip_dst) = packet.right_packet(4);
        packet.context.set_field("test_field_ip_dst2", ip_dst);

        assert_eq!(packet.context.get_field_released("test_field_ether_dst"),
                   None);
        assert_eq!(packet.context.get_field_released("test_field_ether_src"),
                   None);
        assert_eq!(packet.context.get_field_released("test_field_ip_src"), None);
        assert_eq!(packet.context.get_field_released("test_field_ip_dst"), None);

        let ether_dst = packet.context.get_field("test_field_ether_dst2");
        let ether_src = packet.context.get_field("test_field_ether_src2");
        let ip_src = packet.context.get_field("test_field_ip_src2");
        let ip_dst = packet.context.get_field("test_field_ip_dst2");

        assert_eq!(compare_field(expect_ether_dst, ether_src), Equal);
        assert_eq!(compare_field(expect_ether_src, ether_dst), Equal);
        assert_eq!(compare_field(expect_ip_src, ip_dst), Equal);
        assert_eq!(compare_field(expect_ip_dst, ip_src), Equal);
    }
}

#[test]
fn test_ethernet() {
    let mut temp_buffer = ZERO_BUFFER;
    let old_ether_dst: &[u8; 6] = &[0xCDu8; 6];
    let old_ether_src: &[u8; 6] = &[0xBCu8; 6];
    let expect_ether_proto: &[u8; 2] = &[0x08u8, 0x00u8];
    let expect_ether_proto_u16 = 0x0800u16;

    let buffer = prepare_packet1(&mut temp_buffer);

    {
        let mut packet = Packet::new(buffer);
        packet = phy::extract(packet);
        assert_eq!("802.3", packet.context.get_string("phy::protocol"));

        packet = ethernet::extract(packet);
        assert_eq!(Equal,
                   compare_field(old_ether_dst,
                                 packet.context.get_field("ethernet::destination")));
        assert_eq!(Equal,
                   compare_field(old_ether_src, packet.context.get_field("ethernet::source")));
        assert_eq!(Equal,
                   compare_field(expect_ether_proto,
                                 packet.context.get_field("ethernet::protocol")));
        packet = ethernet::extract_protocol_u16(packet);
        assert_eq!(expect_ether_proto_u16,
                   packet.context.get_u16("ethernet::protocol_u16"));
        packet = ethernet::swap_address(packet);
        assert_eq!(Equal,
                   compare_field(old_ether_src,
                                 packet.context.get_field("ethernet::destination")));
        assert_eq!(Equal,
                   compare_field(old_ether_dst, packet.context.get_field("ethernet::source")));
    }
    {
        let mut packet = Packet::new(buffer);
        packet = phy::extract(packet);
        packet = ethernet::extract(packet);
        assert_eq!(Equal,
                   compare_field(old_ether_src,
                                 packet.context.get_field("ethernet::destination")));
        assert_eq!(Equal,
                   compare_field(old_ether_dst, packet.context.get_field("ethernet::source")));
    }
}

fn test_ipv4_1_body(buffer: Field) {
    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x0800, packet.context.get_u16("ethernet::protocol_u16"));

    let packet = ip::extract_version_u8(packet);
    let packet = ipv4::extract(packet);
    let packet = ipv4::extract_dscp_u8(packet);
    let packet = ipv4::extract_ecn_u8(packet);
    let packet = ipv4::extract_fragment_flag_u8(packet);
    let packet = ipv4::extract_fragment_offset_u16(packet);
    let packet = ipv4::extract_header_checksum_u16(packet);
    let packet = ipv4::extract_header_length_u8(packet);
    let packet = ipv4::extract_hop_limit_u8(packet);
    let packet = ipv4::extract_protocol_u8(packet);
    let packet = ipv4::extract_total_length_u16(packet);
    let packet = ipv4::extract_version_u8(packet);

    assert_eq!(true, packet.context.get_bool("ipv4::correct_csum_bool"));
    assert_eq!(4, packet.context.get_u8("ip::version_u8"));
    assert_eq!(4, packet.context.get_u8("ipv4::version_u8"));
    assert_eq!(0, packet.context.get_u8("ipv4::dscp_u8"));
    assert_eq!(40, packet.context.get_u16("ip::total_length_u16"));
    assert_eq!(40, packet.context.get_u16("ipv4::total_length_u16"));
    assert_eq!(Equal,
               compare_field(&[0, 0], packet.context.get_field("ipv4::identification")));
    assert_eq!(0x02, packet.context.get_u8("ipv4::fragment_flag_u8"));
    assert_eq!(0, packet.context.get_u16("ipv4::fragment_offset_u16"));
    assert_eq!(64, packet.context.get_u8("ip::hop_limit_u8"));
    assert_eq!(64, packet.context.get_u8("ipv4::hop_limit_u8"));
    assert_eq!(6, packet.context.get_u8("ip::protocol_u8"));
    assert_eq!(6, packet.context.get_u8("ipv4::protocol_u8"));
    assert_eq!(0x6F1D, packet.context.get_u16("ipv4::header_checksum_u16"));
    assert_eq!(Equal,
               compare_field(&[192, 168, 0, 7], packet.context.get_field("ipv4::source")));
    assert_eq!(Equal,
               compare_field(&[10, 0, 1, 4],
                             packet.context.get_field("ipv4::destination")));
    assert_eq!(Equal,
               compare_field(&[], packet.context.get_field("ipv4::option")));
}

#[test]
fn test_ipv4_1() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    test_ipv4_1_body(buffer);
}

fn test_ipv4_2_body(buffer: Field) {
    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x0800, packet.context.get_u16("ethernet::protocol_u16"));

    let packet = ip::extract_version_u8(packet);
    let packet = ipv4::extract(packet);
    let packet = ipv4::extract_dscp_u8(packet);
    let packet = ipv4::extract_ecn_u8(packet);
    let packet = ipv4::extract_fragment_flag_u8(packet);
    let packet = ipv4::extract_fragment_offset_u16(packet);
    let packet = ipv4::extract_header_checksum_u16(packet);
    let packet = ipv4::extract_header_length_u8(packet);
    let packet = ipv4::extract_hop_limit_u8(packet);
    let packet = ipv4::extract_protocol_u8(packet);
    let packet = ipv4::extract_total_length_u16(packet);
    let packet = ipv4::extract_version_u8(packet);

    assert_eq!(true, packet.context.get_bool("ipv4::correct_csum_bool"));
    assert_eq!(4, packet.context.get_u8("ip::version_u8"));
    assert_eq!(4, packet.context.get_u8("ipv4::version_u8"));
    assert_eq!(0, packet.context.get_u8("ipv4::dscp_u8"));
    assert_eq!(0, packet.context.get_u8("ipv4::ecn_u8"));
    assert_eq!(40, packet.context.get_u16("ip::total_length_u16"));
    assert_eq!(40, packet.context.get_u16("ipv4::total_length_u16"));
    assert_eq!(Equal,
               compare_field(&[0x41, 0x58],
                             packet.context.get_field("ipv4::identification")));
    assert_eq!(0x02, packet.context.get_u8("ipv4::fragment_flag_u8"));
    assert_eq!(0, packet.context.get_u16("ipv4::fragment_offset_u16"));
    assert_eq!(126, packet.context.get_u8("ip::hop_limit_u8"));
    assert_eq!(126, packet.context.get_u8("ipv4::hop_limit_u8"));
    assert_eq!(6, packet.context.get_u8("ip::protocol_u8"));
    assert_eq!(6, packet.context.get_u8("ipv4::protocol_u8"));
    assert_eq!(0x2208, packet.context.get_u16("ipv4::header_checksum_u16"));
    assert_eq!(Equal,
               compare_field(&[10, 3, 1, 92], packet.context.get_field("ipv4::source")));
    assert_eq!(Equal,
               compare_field(&[10, 46, 131, 227],
                             packet.context.get_field("ipv4::destination")));
    assert_eq!(Equal,
               compare_field(&[], packet.context.get_field("ipv4::option")));
}

#[test]
fn test_ipv4_2() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet2(&mut temp_buffer);

    test_ipv4_2_body(buffer);
}

fn test_ipv4_3_body(buffer: Field) {
    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x0800, packet.context.get_u16("ethernet::protocol_u16"));

    let packet = ip::extract_version_u8(packet);
    let packet = ipv4::extract(packet);
    let packet = ipv4::extract_dscp_u8(packet);
    let packet = ipv4::extract_ecn_u8(packet);
    let packet = ipv4::extract_fragment_flag_u8(packet);
    let packet = ipv4::extract_fragment_offset_u16(packet);
    let packet = ipv4::extract_header_checksum_u16(packet);
    let packet = ipv4::extract_header_length_u8(packet);
    let packet = ipv4::extract_hop_limit_u8(packet);
    let packet = ipv4::extract_protocol_u8(packet);
    let packet = ipv4::extract_total_length_u16(packet);
    let packet = ipv4::extract_version_u8(packet);

    assert_eq!(true, packet.context.get_bool("ipv4::correct_csum_bool"));
    assert_eq!(4, packet.context.get_u8("ip::version_u8"));
    assert_eq!(4, packet.context.get_u8("ipv4::version_u8"));
    assert_eq!(0x30, packet.context.get_u8("ipv4::dscp_u8"));
    assert_eq!(0, packet.context.get_u8("ipv4::ecn_u8"));
    assert_eq!(48, packet.context.get_u16("ip::total_length_u16"));
    assert_eq!(48, packet.context.get_u16("ipv4::total_length_u16"));
    assert_eq!(Equal,
               compare_field(&[0, 0], packet.context.get_field("ipv4::identification")));
    assert_eq!(0x00, packet.context.get_u8("ipv4::fragment_flag_u8"));
    assert_eq!(0, packet.context.get_u16("ipv4::fragment_offset_u16"));
    assert_eq!(1, packet.context.get_u8("ip::hop_limit_u8"));
    assert_eq!(1, packet.context.get_u8("ipv4::hop_limit_u8"));
    assert_eq!(17, packet.context.get_u8("ip::protocol_u8"));
    assert_eq!(17, packet.context.get_u8("ipv4::protocol_u8"));
    assert_eq!(0xACFC, packet.context.get_u16("ipv4::header_checksum_u16"));
    assert_eq!(Equal,
               compare_field(&[10, 1, 2, 1], packet.context.get_field("ipv4::source")));
    assert_eq!(Equal,
               compare_field(&[255, 255, 255, 255],
                             packet.context.get_field("ipv4::destination")));
    assert_eq!(Equal,
               compare_field(&[], packet.context.get_field("ipv4::option")));
}

#[test]
fn test_ipv4_3() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet3(&mut temp_buffer);

    test_ipv4_3_body(buffer);
}

fn test_ipv6_1_body(buffer: Field) {
    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x86DD, packet.context.get_u16("ethernet::protocol_u16"));

    let packet = ip::extract_version_u8(packet);
    let packet = ipv6::extract(packet);
    let packet = ipv6::extract_version_u8(packet);
    let packet = ipv6::extract_dscp_u8(packet);
    let packet = ipv6::extract_ecn_u8(packet);
    let packet = ipv6::extract_flow_u32(packet);
    let packet = ipv6::extract_total_length_u16(packet);
    let packet = ipv6::extract_protocol_u8(packet);
    let packet = ipv6::extract_hop_limit_u8(packet);

    assert_eq!(6, packet.context.get_u8("ip::version_u8"));
    assert_eq!(6, packet.context.get_u8("ipv6::version_u8"));
    assert_eq!(0, packet.context.get_u8("ipv6::dscp_u8"));
    assert_eq!(0, packet.context.get_u8("ipv6::ecn_u8"));
    assert_eq!(0, packet.context.get_u32("ipv6::flow_u32"));
    assert_eq!(203, packet.context.get_u16("ip::total_length_u16"));
    assert_eq!(203, packet.context.get_u16("ipv6::total_length_u16"));
    assert_eq!(6, packet.context.get_u8("ip::protocol_u8"));
    assert_eq!(6, packet.context.get_u8("ipv6::protocol_u8"));
    assert_eq!(64, packet.context.get_u8("ip::hop_limit_u8"));
    assert_eq!(64, packet.context.get_u8("ipv6::hop_limit_u8"));
    assert_eq!(Equal,
               compare_field(&[0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                               0x00, 0x00, 0x00, 0x01, 0x33],
                             packet.context.get_field("ipv6::source")));
    assert_eq!(Equal,
               compare_field(&[0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                               0x00, 0x00, 0x00, 0x01, 0x40],
                             packet.context.get_field("ipv6::destination")));
    assert_eq!(187,
               packet.context.get_u32("ipv6::total_length_u32") -
               packet.context.get_u32("ipv6::header_length_u32"));
}

#[test]
fn test_ipv6_1() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet4(&mut temp_buffer);

    test_ipv6_1_body(buffer);
}

fn test_ipv6_2_body(buffer: Field) {
    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x86DD, packet.context.get_u16("ethernet::protocol_u16"));

    let packet = ip::extract_version_u8(packet);
    let packet = ipv6::extract(packet);
    let packet = ipv6::extract_version_u8(packet);
    let packet = ipv6::extract_dscp_u8(packet);
    let packet = ipv6::extract_ecn_u8(packet);
    let packet = ipv6::extract_flow_u32(packet);
    let packet = ipv6::extract_total_length_u16(packet);
    let packet = ipv6::extract_protocol_u8(packet);
    let packet = ipv6::extract_hop_limit_u8(packet);

    assert_eq!(6, packet.context.get_u8("ip::version_u8"));
    assert_eq!(6, packet.context.get_u8("ipv6::version_u8"));
    assert_eq!(0, packet.context.get_u8("ipv6::dscp_u8"));
    assert_eq!(0, packet.context.get_u8("ipv6::ecn_u8"));
    assert_eq!(0, packet.context.get_u32("ipv6::flow_u32"));
    assert_eq!(24, packet.context.get_u16("ip::total_length_u16"));
    assert_eq!(24, packet.context.get_u16("ipv6::total_length_u16"));
    assert_eq!(17, packet.context.get_u8("ip::protocol_u8"));
    assert_eq!(17, packet.context.get_u8("ipv6::protocol_u8"));
    assert_eq!(1, packet.context.get_u8("ip::hop_limit_u8"));
    assert_eq!(1, packet.context.get_u8("ipv6::hop_limit_u8"));
    assert_eq!(Equal,
               compare_field(&[0xFE, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0A, 0xe6,
                               0xFF, 0xFE, 0xAE, 0xA5, 0xA2],
                             packet.context.get_field("ipv6::source")));
    assert_eq!(Equal,
               compare_field(&[0xFF, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                               0x00, 0x00, 0x01, 0x00, 0x06],
                             packet.context.get_field("ipv6::destination")));
    assert_eq!(24,
               packet.context.get_u32("ipv6::total_length_u32") -
               packet.context.get_u32("ipv6::header_length_u32"));
}

#[test]
fn test_ipv6_2() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet5(&mut temp_buffer);

    test_ipv6_2_body(buffer);
}

#[test]
fn test_csum_1() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x0800, packet.context.get_u16("ethernet::protocol_u16"));

    let field_csum;
    let packet_csum;
    {
        let (_, field) = packet.right_packet(20);
        field_csum = field.ones_complement_sum_u16(field.len());
        let packet = Packet::new(field);
        packet_csum = packet.ones_complement_sum_u16(packet.len());
    }
    assert_eq!(0xFFFF, field_csum);
    assert_eq!(0xFFFF, packet_csum);
}

#[test]
fn test_csum_2() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet2(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x0800, packet.context.get_u16("ethernet::protocol_u16"));

    let field_csum;
    let packet_csum;
    {
        let (_, field) = packet.right_packet(20);
        field_csum = field.ones_complement_sum_u16(field.len());
        let packet = Packet::new(field);
        packet_csum = packet.ones_complement_sum_u16(packet.len());
    }
    assert_eq!(0xFFFF, field_csum);
    assert_eq!(0xFFFF, packet_csum);
}

#[test]
fn test_csum_3() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet3(&mut temp_buffer);

    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x0800, packet.context.get_u16("ethernet::protocol_u16"));

    let field_csum;
    let packet_csum;
    {
        let (_, field) = packet.right_packet(20);
        field_csum = field.ones_complement_sum_u16(field.len());
        let packet = Packet::new(field);
        packet_csum = packet.ones_complement_sum_u16(packet.len());
    }
    assert_eq!(0xFFFF, field_csum);
    assert_eq!(0xFFFF, packet_csum);
}

fn test_tcp_1_body(buffer: Field) {
    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x0800, packet.context.get_u16("ethernet::protocol_u16"));

    let packet = ip::extract_version_u8(packet);
    assert_eq!(4, packet.context.get_u8("ip::version_u8"));
    let packet = ipv4::extract(packet);
    let packet = ipv4::extract_protocol_u8(packet);

    assert_eq!(6, packet.context.get_u8("ip::protocol_u8"));

    let packet = tcp::extract(packet);
    let packet = tcp::extract_source_u16(packet);
    let packet = tcp::extract_destination_u16(packet);
    let packet = tcp::extract_sequence_u32(packet);
    let packet = tcp::extract_acknowledgment_u32(packet);
    let packet = tcp::extract_header_length_u8(packet);
    let packet = tcp::extract_flags_u16(packet);
    let packet = tcp::extract_window_u16(packet);
    let packet = tcp::extract_checksum_u16(packet);
    let packet = tcp::extract_urgent_u16(packet);

    assert_eq!(true, packet.context.get_bool("tcp::correct_csum_bool"));
    assert_eq!(22222, packet.context.get_u16("tcp::source_u16"));
    assert_eq!(22222, packet.context.get_u16("l4::source_u16"));
    assert_eq!(12345, packet.context.get_u16("tcp::destination_u16"));
    assert_eq!(12345, packet.context.get_u16("l4::destination_u16"));
    assert_eq!(4278724791, packet.context.get_u32("tcp::sequence_u32"));
    assert_eq!(0, packet.context.get_u32("tcp::acknowledgment_u32"));
    assert_eq!(20, packet.context.get_u8("tcp::header_length_u8"));
    assert_eq!(0x0002, packet.context.get_u16("tcp::flags_u16"));
    assert_eq!(51200, packet.context.get_u16("tcp::window_u16"));
    assert_eq!(0x6D67, packet.context.get_u16("tcp::checksum_u16"));
    assert_eq!(0, packet.context.get_u16("tcp::urgent_u16"));
}

#[test]
fn test_tcp_1() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet1(&mut temp_buffer);

    test_tcp_1_body(buffer);
}

fn test_tcp_2_body(buffer: Field) {
    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x0800, packet.context.get_u16("ethernet::protocol_u16"));

    let packet = ip::extract_version_u8(packet);
    assert_eq!(4, packet.context.get_u8("ip::version_u8"));
    let packet = ipv4::extract(packet);
    let packet = ipv4::extract_protocol_u8(packet);

    assert_eq!(6, packet.context.get_u8("ip::protocol_u8"));

    let packet = tcp::extract(packet);
    let packet = tcp::extract_source_u16(packet);
    let packet = tcp::extract_destination_u16(packet);
    let packet = tcp::extract_sequence_u32(packet);
    let packet = tcp::extract_acknowledgment_u32(packet);
    let packet = tcp::extract_header_length_u8(packet);
    let packet = tcp::extract_flags_u16(packet);
    let packet = tcp::extract_window_u16(packet);
    let packet = tcp::extract_checksum_u16(packet);
    let packet = tcp::extract_urgent_u16(packet);

    assert_eq!(true, packet.context.get_bool("tcp::correct_csum_bool"));
    assert_eq!(8080, packet.context.get_u16("tcp::source_u16"));
    assert_eq!(8080, packet.context.get_u16("l4::source_u16"));
    assert_eq!(2114, packet.context.get_u16("tcp::destination_u16"));
    assert_eq!(2114, packet.context.get_u16("l4::destination_u16"));
    assert_eq!(3367900807, packet.context.get_u32("tcp::sequence_u32"));
    assert_eq!(2160489343,
               packet.context.get_u32("tcp::acknowledgment_u32"));
    assert_eq!(20, packet.context.get_u8("tcp::header_length_u8"));
    assert_eq!(0x0011, packet.context.get_u16("tcp::flags_u16"));
    assert_eq!(64240, packet.context.get_u16("tcp::window_u16"));
    assert_eq!(0x2015, packet.context.get_u16("tcp::checksum_u16"));
    assert_eq!(0, packet.context.get_u16("tcp::urgent_u16"));
}

#[test]
fn test_tcp_2() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet2(&mut temp_buffer);

    test_tcp_2_body(buffer);
}

fn test_tcp_3_body(buffer: Field) {
    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x86DD, packet.context.get_u16("ethernet::protocol_u16"));

    let packet = ip::extract_version_u8(packet);
    assert_eq!(6, packet.context.get_u8("ip::version_u8"));
    let packet = ipv6::extract(packet);
    let packet = ipv6::extract_protocol_u8(packet);

    assert_eq!(6, packet.context.get_u8("ip::protocol_u8"));

    let packet = tcp::extract(packet);
    let packet = tcp::extract_source_u16(packet);
    let packet = tcp::extract_destination_u16(packet);
    let packet = tcp::extract_sequence_u32(packet);
    let packet = tcp::extract_acknowledgment_u32(packet);
    let packet = tcp::extract_header_length_u8(packet);
    let packet = tcp::extract_flags_u16(packet);
    let packet = tcp::extract_window_u16(packet);
    let packet = tcp::extract_checksum_u16(packet);
    let packet = tcp::extract_urgent_u16(packet);

    assert_eq!(true, packet.context.get_bool("tcp::correct_csum_bool"));
    assert_eq!(55617, packet.context.get_u16("tcp::source_u16"));
    assert_eq!(55617, packet.context.get_u16("l4::source_u16"));
    assert_eq!(80, packet.context.get_u16("tcp::destination_u16"));
    assert_eq!(80, packet.context.get_u16("l4::destination_u16"));
    assert_eq!(1854968068, packet.context.get_u32("tcp::sequence_u32"));
    assert_eq!(1892091846,
               packet.context.get_u32("tcp::acknowledgment_u32"));
    assert_eq!(32, packet.context.get_u8("tcp::header_length_u8"));
    assert_eq!(0x0018, packet.context.get_u16("tcp::flags_u16"));
    assert_eq!(45, packet.context.get_u16("tcp::window_u16"));
    assert_eq!(0x3050, packet.context.get_u16("tcp::checksum_u16"));
    assert_eq!(0, packet.context.get_u16("tcp::urgent_u16"));
}

#[test]
fn test_tcp_3() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet4(&mut temp_buffer);

    test_tcp_3_body(buffer);
}

fn test_udp_1_body(buffer: Field) {
    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x0800, packet.context.get_u16("ethernet::protocol_u16"));

    let packet = ip::extract_version_u8(packet);
    assert_eq!(4, packet.context.get_u8("ip::version_u8"));
    let packet = ipv4::extract(packet);
    let packet = ipv4::extract_protocol_u8(packet);

    assert_eq!(17, packet.context.get_u8("ip::protocol_u8"));

    let packet = udp::extract(packet);
    let packet = udp::extract_source_u16(packet);
    let packet = udp::extract_destination_u16(packet);
    let packet = udp::extract_length_u16(packet);
    let packet = udp::extract_checksum_u16(packet);

    assert_eq!(true, packet.context.get_bool("udp::correct_csum_bool"));
    assert_eq!(711, packet.context.get_u16("udp::source_u16"));
    assert_eq!(711, packet.context.get_u16("l4::source_u16"));
    assert_eq!(711, packet.context.get_u16("udp::destination_u16"));
    assert_eq!(711, packet.context.get_u16("l4::destination_u16"));
    assert_eq!(28, packet.context.get_u16("udp::length_u16"));
    assert_eq!(0xC9FC, packet.context.get_u16("udp::checksum_u16"));
}

#[test]
fn test_udp_1() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet3(&mut temp_buffer);

    test_udp_1_body(buffer);
}

fn test_udp_2_body(buffer: Field) {
    let packet = Packet::new(buffer);
    let packet = phy::extract(packet);
    let packet = ethernet::extract(packet);
    let packet = ethernet::extract_protocol_u16(packet);

    assert_eq!(0x86DD, packet.context.get_u16("ethernet::protocol_u16"));

    let packet = ip::extract_version_u8(packet);
    assert_eq!(6, packet.context.get_u8("ip::version_u8"));
    let packet = ipv6::extract(packet);
    let packet = ipv6::extract_protocol_u8(packet);

    assert_eq!(17, packet.context.get_u8("ip::protocol_u8"));

    let packet = udp::extract(packet);
    let packet = udp::extract_source_u16(packet);
    let packet = udp::extract_destination_u16(packet);
    let packet = udp::extract_length_u16(packet);
    let packet = udp::extract_checksum_u16(packet);

    assert_eq!(true, packet.context.get_bool("udp::correct_csum_bool"));
    assert_eq!(6697, packet.context.get_u16("udp::source_u16"));
    assert_eq!(6697, packet.context.get_u16("l4::source_u16"));
    assert_eq!(6697, packet.context.get_u16("udp::destination_u16"));
    assert_eq!(6697, packet.context.get_u16("l4::destination_u16"));
    assert_eq!(24, packet.context.get_u16("udp::length_u16"));
    assert_eq!(0x330B, packet.context.get_u16("udp::checksum_u16"));
}

#[test]
fn test_udp_2() {
    let mut temp_buffer = ZERO_BUFFER;
    let buffer = prepare_packet5(&mut temp_buffer);

    test_udp_2_body(buffer);
}

#[test]
fn test_ffi_mapping() {
    let mut temp_buffer = ZERO_BUFFER;

    let buffer = prepare_packet1(&mut temp_buffer);
    let mapper = millefeuille_ffi_map!();

    let packet = Packet::new(buffer);
    if let Some(handler) = mapper("packet::dummy_move") {
    	handler(packet);
    } else {
    	panic!("Cannot reach here");
    }
}

#[test]
fn test_build_tcp() {
    let mut temp_buffer = ZERO_BUFFER;
    let start_offset;
    {
        let buffer = &mut temp_buffer;
        let mut packet = Packet::new(buffer);
        packet.context.set_usize("app::payload_usize", 6);
        packet = app::fill(packet);
        packet = tcp::fill(packet);
        packet = ipv4::fill(packet);
        packet = ethernet::fill(packet);
        packet = phy::fill(packet);
        start_offset = packet.context.get_usize("phy::headroom_usize");
        
        packet.context.set_u64("ethernet::destination_u64", 0x000bdb4d6a3b0000);
        packet.context.set_u64("ethernet::source_u64", 0x00166057e2060000);
        packet.context.set_u16("ethernet::protocol_u16", 0x0800);
        
        packet.context.set_u8("ipv4::version_u8", 4);
        packet.context.set_u8("ipv4::header_length_u8", 20);
        packet.context.set_u8("ipv4::dscp_u8", 0);
        packet.context.set_u8("ipv4::ecn_u8", 0);
        packet.context.set_u16("ipv4::total_length_u16", 40);
        packet.context.set_u16("ipv4::identification_u16", 0x4158);
        packet.context.set_u8("ipv4::fragment_flag_u8", 0x02);
        packet.context.set_u16("ipv4::fragment_offset_u16", 0);
        packet.context.set_u8("ipv4::hop_limit_u8", 126);
        packet.context.set_u8("ipv4::protocol_u8", 6);
        packet.context.set_u16("ipv4::header_checksum_u16", 0xABCD); //Not correct value
        packet.context.set_u32("ipv4::source_u32", 0x0A03015C);
        packet.context.set_u32("ipv4::destination_u32", 0x0A2E83E3);
        
        packet.context.set_u16("tcp::source_u16", 8080);
        packet.context.set_u16("tcp::destination_u16", 2114);
        packet.context.set_u32("tcp::sequence_u32", 3367900807);
        packet.context.set_u32("tcp::acknowledgment_u32", 2160489343);
        packet.context.set_u8("tcp::header_length_u8", 20);
        packet.context.set_u16("tcp::flags_u16", 0x0011);
        packet.context.set_u16("tcp::window_u16", 64240);
        packet.context.set_u16("tcp::checksum_u16", 0xABCD); //Not correct value
        packet.context.set_u16("tcp::urgent_u16", 0);
        
        packet = ethernet::apply_destination(packet);
		packet = ethernet::apply_source(packet);
        packet = ethernet::apply_protocol(packet);
                
        packet = ipv4::apply_version(packet);
        packet = ipv4::apply_header_length(packet);
        packet = ipv4::apply_dscp(packet);
        packet = ipv4::apply_ecn(packet);
        packet = ipv4::apply_total_length(packet);
        packet = ipv4::apply_identification(packet);
        packet = ipv4::apply_fragment_flag(packet);
        packet = ipv4::apply_fragment_offset(packet);
        packet = ipv4::apply_hop_limit(packet);
        packet = ipv4::apply_protocol(packet);
        packet = ipv4::apply_header_checksum(packet);
        packet = ipv4::apply_source(packet);
        packet = ipv4::apply_destination(packet);
                
        packet = tcp::apply_source(packet);
        packet = tcp::apply_destination(packet);
        packet = tcp::apply_sequence(packet);
        packet = tcp::apply_acknowledgment(packet);
        packet = tcp::apply_header_length(packet);
        packet = tcp::apply_flags(packet);
        packet = tcp::apply_window(packet);
        packet = tcp::apply_checksum(packet);
        tcp::apply_urgent(packet);
    }
    {
        let buffer = &mut temp_buffer[start_offset..];
        let mut packet = Packet::new(buffer);
        
        packet = phy::extract(packet);
        packet = ethernet::extract(packet);
        packet = ipv4::extract(packet);
        packet = tcp::extract(packet);
        
        packet = ipv4::apply_current_checksum(packet);
        tcp::apply_current_checksum(packet);
    }
    {
        let buffer = &mut temp_buffer[start_offset..];
        test_ipv4_2_body(buffer);
        test_tcp_2_body(buffer);
    }
    {
        let mut temp_buffer2 = ZERO_BUFFER;
        let buffer = &temp_buffer[start_offset..];
        let original_buffer = prepare_packet2(&mut temp_buffer2);
        assert_eq!(Equal,
            packet::compare_field(buffer, original_buffer)
        );
    }
}

#[test]
fn test_build_udp() {
    let mut temp_buffer = ZERO_BUFFER;
    let start_offset;
    {
        let buffer = &mut temp_buffer;
        let mut packet = Packet::new(buffer);
        packet.context.set_usize("app::payload_usize", 16);
        packet = app::fill(packet);
        {
        	let field = packet.context.take_field("app::payload");
        	packet::move_field(&[
        	    0x2a, 0x02, 0x00, 0x0c, 0x04, 0x06, 0x00, 0x00,
        	    0xce, 0x94, 0x07, 0xd0, 0x09, 0x02, 0x00, 0x00,
        	    ], field
        	);
        	packet.context.set_field("app::payload", field);
        }
        packet = udp::fill(packet);
        packet = ipv6::fill(packet);
        packet = ethernet::fill(packet);
        packet = phy::fill(packet);
        start_offset = packet.context.get_usize("phy::headroom_usize");
        
        packet.context.set_u64("ethernet::destination_u64", 0x3333000100060000);
        packet.context.set_u64("ethernet::source_u64", 0x000ae6aea5a20000);
        packet.context.set_u16("ethernet::protocol_u16", 0x86dd);
        
        packet.context.set_u8("ipv6::version_u8", 6);
        packet.context.set_u8("ipv6::dscp_u8", 0);
        packet.context.set_u8("ipv6::ecn_u8", 0);
        packet.context.set_u32("ipv6::flow_u32", 0);
        packet.context.set_u16("ipv6::total_length_u16", 24);
        packet.context.set_u8("ipv6::hop_limit_u8", 1);
        packet.context.set_u8("ipv6::protocol_u8", 17);
        packet.context.set_u64("ipv6::source0_u64", 0xfe80000000000000);
        packet.context.set_u64("ipv6::source1_u64", 0x020ae6fffeaea5a2);
        packet.context.set_u64("ipv6::destination0_u64", 0xff02000000000000);
        packet.context.set_u64("ipv6::destination1_u64", 0x0000000000010006);
        
        packet.context.set_u16("udp::source_u16", 6697);
        packet.context.set_u16("udp::destination_u16", 6697);
        packet.context.set_u16("udp::length_u16", 24);
        packet.context.set_u16("udp::checksum_u16", 0xABCD); //Not correct value
        
        packet = ethernet::apply_destination(packet);
		packet = ethernet::apply_source(packet);
        packet = ethernet::apply_protocol(packet);
                
        packet = ipv6::apply_version(packet);
        packet = ipv6::apply_dscp(packet);
        packet = ipv6::apply_ecn(packet);
        packet = ipv6::apply_flow(packet);
        packet = ipv6::apply_total_length(packet);
        packet = ipv6::apply_hop_limit(packet);
        packet = ipv6::apply_protocol(packet);
        packet = ipv6::apply_source(packet);
        packet = ipv6::apply_destination(packet);
        
        packet = udp::apply_source(packet);
        packet = udp::apply_destination(packet);
        packet = udp::apply_length(packet);
        udp::apply_checksum(packet);
    }
    {
        let buffer = &mut temp_buffer[start_offset..];
        let mut packet = Packet::new(buffer);
        
        packet = phy::extract(packet);
        packet = ethernet::extract(packet);
        packet = ipv6::extract(packet);
        packet = udp::extract(packet);
        
        udp::apply_current_checksum(packet);
    }
    {
        let buffer = &mut temp_buffer[start_offset..];
        test_ipv6_2_body(buffer);
        test_udp_2_body(buffer);
    }
    {
        let mut temp_buffer2 = ZERO_BUFFER;
        let buffer = &temp_buffer[start_offset..];
        let original_buffer = prepare_packet5(&mut temp_buffer2);
        assert_eq!(Equal,
            packet::compare_field(buffer, original_buffer)
        );
    }
}