Skip to content

Commit

Permalink
Refactor WinPacket
Browse files Browse the repository at this point in the history 
- Add WinPacketRaw for all OS-dependent operations
- Refactor WinPacket

Change-Id: I74d2b92e565f2e219eee0a583e8a021bdbcd333d
Partial-Bug: #1737177
  • Loading branch information
@jablonskim
jablonskim committed Jul 13, 2018
1 parent 50c8296 commit 8582f48
Show file tree
Hide file tree
Showing 13 changed files with 265 additions and 173 deletions.
64 changes: 35 additions & 29 deletions test/windows/fake_win_packet_raw.c
View file
Expand Up @@ -4,6 +4,7 @@
* Copyright (c) 2018 Juniper Networks, Inc. All rights reserved.
*/
#include "win_packet_raw.h"
#include "win_packet_impl.h"
#include "fake_win_packet.h"

#include <assert.h>
Expand All @@ -12,18 +13,22 @@
#include <setjmp.h>
#include <cmocka.h>

struct _WIN_PACKET {
PWIN_PACKET Parent;
struct _WIN_PACKET_RAW {
PWIN_PACKET_RAW Parent;
long ChildRefCount;
bool IsOwned;
};

struct _WIN_PACKET {
WIN_PACKET_RAW Packet;
};

static PWIN_PACKET
Fake_WinPacketAllocate(bool IsOwned)
{
PWIN_PACKET packet = test_calloc(1, sizeof(*packet));
assert(packet != NULL);
packet->IsOwned = IsOwned;
WinPacketToRawPacket(packet)->IsOwned = IsOwned;
return packet;
}

Expand All @@ -45,96 +50,97 @@ Fake_WinPacketFree(PWIN_PACKET Packet)
test_free(Packet);
}

PWIN_PACKET
WinPacketRawGetParentOf(PWIN_PACKET Packet)
PWIN_PACKET_RAW
WinPacketRawGetParentOf(PWIN_PACKET_RAW Packet)
{
return Packet->Parent;
}

void
WinPacketRawSetParentOf(PWIN_PACKET Packet, PWIN_PACKET Parent)
WinPacketRawSetParentOf(PWIN_PACKET_RAW Packet, PWIN_PACKET_RAW Parent)
{
Packet->Parent = Parent;
}

long
WinPacketRawGetChildCountOf(PWIN_PACKET Packet)
WinPacketRawGetChildCountOf(PWIN_PACKET_RAW Packet)
{
return Packet->ChildRefCount;
}

long
WinPacketRawIncrementChildCountOf(PWIN_PACKET Packet)
WinPacketRawIncrementChildCountOf(PWIN_PACKET_RAW Packet)
{
return ++Packet->ChildRefCount;
}

long
WinPacketRawDecrementChildCountOf(PWIN_PACKET Packet)
WinPacketRawDecrementChildCountOf(PWIN_PACKET_RAW Packet)
{
return --Packet->ChildRefCount;
}

static PWIN_PACKET
WinPacketRawAllocateClone_Impl(PWIN_PACKET Packet)
static PWIN_PACKET_RAW
WinPacketRawAllocateClone_Impl(PWIN_PACKET_RAW Packet)
{
return Fake_WinPacketAllocateOwned();
PWIN_PACKET_RAW cloned = WinPacketToRawPacket(Fake_WinPacketAllocateOwned());
return cloned;
}
PWIN_PACKET (*WinPacketRawAllocateClone_Callback)(PWIN_PACKET Packet) = WinPacketRawAllocateClone_Impl;
PWIN_PACKET_RAW (*WinPacketRawAllocateClone_Callback)(PWIN_PACKET_RAW Packet) = WinPacketRawAllocateClone_Impl;

PWIN_PACKET
WinPacketRawAllocateClone(PWIN_PACKET Packet)
PWIN_PACKET_RAW
WinPacketRawAllocateClone(PWIN_PACKET_RAW Packet)
{
return WinPacketRawAllocateClone_Callback(Packet);
}

static void
WinPacketRawFreeClone_Impl(PWIN_PACKET Packet)
WinPacketRawFreeClone_Impl(PWIN_PACKET_RAW Packet)
{
Fake_WinPacketFree(Packet);
Fake_WinPacketFree((PWIN_PACKET)Packet);
}
void (*WinPacketRawFreeClone_Callback)(PWIN_PACKET Packet) = WinPacketRawFreeClone_Impl;
void (*WinPacketRawFreeClone_Callback)(PWIN_PACKET_RAW Packet) = WinPacketRawFreeClone_Impl;

void
WinPacketRawFreeClone(PWIN_PACKET Packet)
WinPacketRawFreeClone(PWIN_PACKET_RAW Packet)
{
WinPacketRawFreeClone_Callback(Packet);
}

bool
WinPacketRawIsOwned(PWIN_PACKET Packet)
WinPacketRawIsOwned(PWIN_PACKET_RAW Packet)
{
return Packet->IsOwned;
}

bool
WinPacketRawIsCloned(PWIN_PACKET Packet)
WinPacketRawIsCloned(PWIN_PACKET_RAW Packet)
{
return Packet->Parent != NULL;
}

static void
WinPacketRawComplete_Impl(PWIN_PACKET Packet)
WinPacketRawComplete_Impl(PWIN_PACKET_RAW Packet)
{
Fake_WinPacketFree(Packet);
Fake_WinPacketFree((PWIN_PACKET)Packet);
}
void (*WinPacketRawComplete_Callback)(PWIN_PACKET Packet) = WinPacketRawComplete_Impl;
void (*WinPacketRawComplete_Callback)(PWIN_PACKET_RAW Packet) = WinPacketRawComplete_Impl;

void
WinPacketRawComplete(PWIN_PACKET Packet)
WinPacketRawComplete(PWIN_PACKET_RAW Packet)
{
WinPacketRawComplete_Callback(Packet);
}

static void
WinPacketRawFreeCreated_Impl(PWIN_PACKET Packet)
WinPacketRawFreeCreated_Impl(PWIN_PACKET_RAW Packet)
{
Fake_WinPacketFree(Packet);
Fake_WinPacketFree((PWIN_PACKET)Packet);
}
void (*WinPacketRawFreeCreated_Callback)(PWIN_PACKET Packet) = WinPacketRawFreeCreated_Impl;
void (*WinPacketRawFreeCreated_Callback)(PWIN_PACKET_RAW Packet) = WinPacketRawFreeCreated_Impl;

void
WinPacketRawFreeCreated(PWIN_PACKET Packet)
WinPacketRawFreeCreated(PWIN_PACKET_RAW Packet)
{
WinPacketRawFreeCreated_Callback(Packet);
}
9 changes: 5 additions & 4 deletions test/windows/include/fake_win_packet.h
View file
Expand Up @@ -7,14 +7,15 @@
#define _FAKE_WIN_PACKET_H_

#include "win_packet.h"
#include "win_packet_raw.h"

PWIN_PACKET Fake_WinPacketAllocateOwned();
PWIN_PACKET Fake_WinPacketAllocateNonOwned();
VOID Fake_WinPacketFree(PWIN_PACKET Packet);

extern PWIN_PACKET (*WinPacketRawAllocateClone_Callback)(PWIN_PACKET Packet);
extern void (*WinPacketRawComplete_Callback)(PWIN_PACKET Packet);
extern void (*WinPacketRawFreeCreated_Callback)(PWIN_PACKET Packet);
extern void (*WinPacketRawFreeClone_Callback)(PWIN_PACKET Packet);
extern PWIN_PACKET_RAW (*WinPacketRawAllocateClone_Callback)(PWIN_PACKET_RAW Packet);
extern void (*WinPacketRawComplete_Callback)(PWIN_PACKET_RAW Packet);
extern void (*WinPacketRawFreeCreated_Callback)(PWIN_PACKET_RAW Packet);
extern void (*WinPacketRawFreeClone_Callback)(PWIN_PACKET_RAW Packet);

#endif // _FAKE_WIN_PACKET_H_
58 changes: 36 additions & 22 deletions test/windows/test_win_packet_clone.c
View file
Expand Up @@ -11,20 +11,21 @@
#include <cmocka.h>

#include "win_packet.h"
#include "win_packet_impl.h"
#include "fake_win_packet.h"

static PWIN_PACKET (*Saved_WinPacketRawAllocateClone)(PWIN_PACKET Packet);
static PWIN_PACKET_RAW (*Saved_WinPacketRawAllocateClone)(PWIN_PACKET_RAW Packet);

static PWIN_PACKET
Fake_WinPacketRawAllocateClone_ReturnsNull(PWIN_PACKET Packet)
static PWIN_PACKET_RAW
Fake_WinPacketRawAllocateClone_ReturnsNull(PWIN_PACKET_RAW Packet)
{
return NULL;
}

static PWIN_PACKET
Fake_WinPacketRawAllocateClone_ReturnsNewPacket(PWIN_PACKET Packet)
static PWIN_PACKET_RAW
Fake_WinPacketRawAllocateClone_ReturnsNewPacket(PWIN_PACKET_RAW Packet)
{
return Fake_WinPacketAllocateOwned();
return WinPacketToRawPacket(Fake_WinPacketAllocateOwned());
}

int
Expand All @@ -48,10 +49,11 @@ Test_WinPacketClone_ReturnsNullWhenCloneFails(void **state)
Fake_WinPacketRawAllocateClone_ReturnsNull;

PWIN_PACKET packet = Fake_WinPacketAllocateNonOwned();
PWIN_PACKET_RAW rawPacket = WinPacketToRawPacket(packet);
PWIN_PACKET cloned = WinPacketClone(packet);

assert_null(cloned);
assert_int_equal(WinPacketRawGetChildCountOf(packet), 0);
assert_int_equal(WinPacketRawGetChildCountOf(rawPacket), 0);

Fake_WinPacketFree(packet);
}
Expand All @@ -65,9 +67,12 @@ Test_WinPacketClone_ReturnsPacketWhenCloneSucceeds(void **state)
PWIN_PACKET packet = Fake_WinPacketAllocateNonOwned();
PWIN_PACKET cloned = WinPacketClone(packet);

assert_non_null(cloned);
assert_ptr_equal(WinPacketRawGetParentOf(cloned), packet);
assert_int_equal(WinPacketRawGetChildCountOf(packet), 1);
PWIN_PACKET_RAW rawPacket = WinPacketToRawPacket(packet);
PWIN_PACKET_RAW rawCloned = WinPacketToRawPacket(cloned);

assert_non_null(rawCloned);
assert_ptr_equal(WinPacketRawGetParentOf(rawCloned), rawPacket);
assert_int_equal(WinPacketRawGetChildCountOf(rawPacket), 1);

Fake_WinPacketFree(cloned);
Fake_WinPacketFree(packet);
Expand All @@ -85,14 +90,19 @@ Test_WinPacketClone_RefCountIsValidAfterMultipleClones(void **state)
PWIN_PACKET cloned2 = WinPacketClone(packet);
PWIN_PACKET cloned3 = WinPacketClone(packet);

assert_ptr_equal(WinPacketRawGetParentOf(cloned1), packet);
assert_ptr_equal(WinPacketRawGetParentOf(cloned2), packet);
assert_ptr_equal(WinPacketRawGetParentOf(cloned3), packet);
PWIN_PACKET_RAW rawPacket = WinPacketToRawPacket(packet);
PWIN_PACKET_RAW rawCloned1 = WinPacketToRawPacket(cloned1);
PWIN_PACKET_RAW rawCloned2 = WinPacketToRawPacket(cloned2);
PWIN_PACKET_RAW rawCloned3 = WinPacketToRawPacket(cloned3);

assert_ptr_equal(WinPacketRawGetParentOf(rawCloned1), rawPacket);
assert_ptr_equal(WinPacketRawGetParentOf(rawCloned2), rawPacket);
assert_ptr_equal(WinPacketRawGetParentOf(rawCloned3), rawPacket);

assert_int_equal(WinPacketRawGetChildCountOf(packet), 3);
assert_int_equal(WinPacketRawGetChildCountOf(cloned1), 0);
assert_int_equal(WinPacketRawGetChildCountOf(cloned2), 0);
assert_int_equal(WinPacketRawGetChildCountOf(cloned3), 0);
assert_int_equal(WinPacketRawGetChildCountOf(rawPacket), 3);
assert_int_equal(WinPacketRawGetChildCountOf(rawCloned1), 0);
assert_int_equal(WinPacketRawGetChildCountOf(rawCloned2), 0);
assert_int_equal(WinPacketRawGetChildCountOf(rawCloned3), 0);

Fake_WinPacketFree(cloned1);
Fake_WinPacketFree(cloned2);
Expand All @@ -111,12 +121,16 @@ Test_WinPacketClone_RefCountIsValidAfterCloneOfClone(void **state)
PWIN_PACKET cloned1 = WinPacketClone(packet);
PWIN_PACKET cloned2 = WinPacketClone(cloned1);

assert_ptr_equal(WinPacketRawGetParentOf(cloned1), packet);
assert_ptr_equal(WinPacketRawGetParentOf(cloned2), cloned1);
PWIN_PACKET_RAW rawPacket = WinPacketToRawPacket(packet);
PWIN_PACKET_RAW rawCloned1 = WinPacketToRawPacket(cloned1);
PWIN_PACKET_RAW rawCloned2 = WinPacketToRawPacket(cloned2);

assert_ptr_equal(WinPacketRawGetParentOf(rawCloned1), rawPacket);
assert_ptr_equal(WinPacketRawGetParentOf(rawCloned2), rawCloned1);

assert_int_equal(WinPacketRawGetChildCountOf(packet), 1);
assert_int_equal(WinPacketRawGetChildCountOf(cloned1), 1);
assert_int_equal(WinPacketRawGetChildCountOf(cloned2), 0);
assert_int_equal(WinPacketRawGetChildCountOf(rawPacket), 1);
assert_int_equal(WinPacketRawGetChildCountOf(rawCloned1), 1);
assert_int_equal(WinPacketRawGetChildCountOf(rawCloned2), 0);

Fake_WinPacketFree(cloned2);
Fake_WinPacketFree(cloned1);
Expand Down

0 comments on commit 8582f48

Please sign in to comment.