win_pclone/win_pfree refactor and unit tests

Change-Id: I120f06f4e030f33a1578edd41d5c414fe5c22b32
Partial-Bug: #1737177

test/windows/SConscript

@@ -20,7 +20,7 @@ env.Append(LIBS = 'cmocka')
 
 env.AppendENVPath('Path', Dir('#build/bin'))
 
-common_tests_src = ['fake_win_packet_raw.c']
+common_tests_src = ['fake_win_packet_raw.c', 'fake_win_memory.c', 'fake_vrouter.c']
 common_tests_obj = env.Object(common_tests_src)
 
 win_packet_clone_tests_src = ['test_win_packet_clone.c'] + common_tests_obj
@@ -29,9 +29,17 @@ win_packet_clone_tests = env.UnitTest('win_packet_clone_tests', win_packet_clone
 win_packet_free_tests_src = ['test_win_packet_free.c'] + common_tests_obj
 win_packet_free_tests = env.UnitTest('win_packet_free_tests', win_packet_free_tests_src)
 
+win_pclone_tests_src = ['test_win_pclone.c'] + common_tests_obj
+win_pclone_tests = env.UnitTest('win_pclone_tests', win_pclone_tests_src)
+
+win_pfree_tests_src = ['test_win_pfree.c'] + common_tests_obj
+win_pfree_tests = env.UnitTest('win_pfree_tests', win_pfree_tests_src)
+
 test_suites = [
     win_packet_clone_tests,
     win_packet_free_tests,
+    win_pclone_tests,
+    win_pfree_tests,
 ]
 
 kernel_tests = env.TestSuite('kernel-tests', test_suites)

test/windows/fake_vrouter.c

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2018 Juniper Networks, Inc. All rights reserved.
+ */
+void
+win_update_drop_stats(struct vr_packet *pkt, unsigned short reason)
+{
+}

test/windows/fake_win_memory.c

@@ -0,0 +1,26 @@
+/*
+ * fake_win_memory.c
+ *
+ * Copyright (c) 2018 Juniper Networks, Inc. All rights reserved.
+ */
+
+#include "win_memory.h"
+
+#include <stdarg.h>
+#include <stdint.h>
+#include <setjmp.h>
+#include <cmocka.h>
+
+void
+WinRawFree(void *buffer)
+{
+    test_free(buffer);
+}
+
+void *(*WinRawAllocate_Callback)(size_t size);
+
+void *
+WinRawAllocate(size_t size)
+{
+    return WinRawAllocate_Callback(size);
+}

test/windows/fake_win_packet_raw.c

@@ -3,6 +3,7 @@
  *
  * Copyright (c) 2018 Juniper Networks, Inc. All rights reserved.
  */
+#include "win_packet_raw.h"
 #include "fake_win_packet.h"
 
 #include <assert.h>

test/windows/test_win_pclone.c

@@ -0,0 +1,185 @@
+/*
+ * test_win_pclone.c
+ *
+ * Copyright (c) 2018 Juniper Networks, Inc. All rights reserved.
+ */
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <setjmp.h>
+#include <cmocka.h>
+
+#include "vr_packet.h"
+#include "win_packet.h"
+#include "fake_win_packet.h"
+
+extern struct vr_packet *win_pclone(struct vr_packet *pkt);
+
+static PWIN_PACKET (*Saved_WinPacketRawAllocateClone)(PWIN_PACKET Packet);
+static PVOID (*Saved_WinRawAllocate)(size_t size);
+
+static uint32_t RawAllocateClone_CalledCount;
+static uint32_t RawAllocateClone_FirstFailure;
+
+static void
+Fake_WinPacketRawAllocateClone_SetFailureOnNthCall(uint32_t N)
+{
+    RawAllocateClone_CalledCount = 0;
+    RawAllocateClone_FirstFailure = N;
+}
+
+static PWIN_PACKET
+Failing_WinPacketRawAllocateClone(PWIN_PACKET Packet)
+{
+    RawAllocateClone_CalledCount++;
+    if (RawAllocateClone_CalledCount >= RawAllocateClone_FirstFailure) {
+        return NULL;
+    } else {
+        return Fake_WinPacketAllocateOwned();
+    }
+}
+
+static PWIN_PACKET
+Succeeding_WinPacketRawAllocateClone(PWIN_PACKET Packet)
+{
+    return Fake_WinPacketAllocateOwned();
+}
+
+static PVOID
+Failing_WinRawAllocate(size_t size)
+{
+    return NULL;
+}
+
+static PVOID
+Succeeding_WinRawAllocate(size_t size)
+{
+    return test_calloc(1, size);
+}
+
+extern PVOID (*WinRawAllocate_Callback)(size_t size);
+
+static struct vr_packet *
+AllocateVrPacketNonOwned(VOID)
+{
+    PVR_PACKET_WRAPPER pkt = test_calloc(1, sizeof(*pkt));
+    pkt->WinPacket = Fake_WinPacketAllocateNonOwned();
+    return &pkt->VrPacket;
+}
+
+static VOID
+FreeVrPacket(struct vr_packet * vrPkt)
+{
+    win_pfree(vrPkt, 0);
+}
+
+//Use _ suffix because there already exists "GetParent" function in WDK
+static PWIN_PACKET
+GetParent_(struct vr_packet * vrPkt)
+{
+    PWIN_PACKET winPacket = GetWinPacketFromVrPacket(vrPkt);
+    return WinPacketRawGetParentOf(winPacket);
+}
+
+int
+Test_win_pclone_SetUp(void **state)
+{
+    Saved_WinPacketRawAllocateClone = WinPacketRawAllocateClone_Callback;
+    Saved_WinRawAllocate = WinRawAllocate_Callback;
+    return 0;
+}
+
+int
+Test_win_pclone_TearDown(void** state)
+{
+    WinPacketRawAllocateClone_Callback = Saved_WinPacketRawAllocateClone;
+    WinRawAllocate_Callback = Saved_WinRawAllocate;
+    return 0;
+}
+
+void
+Test_win_pclone_ReturnsNullWhenNullIsPassed(void **state)
+{
+    expect_assert_failure(win_pclone(NULL));
+}
+
+void
+Test_win_pclone_ReturnsNullWhenFirstCloneFails(void **state)
+{
+    WinPacketRawAllocateClone_Callback = Failing_WinPacketRawAllocateClone;
+    Fake_WinPacketRawAllocateClone_SetFailureOnNthCall(1);
+
+    struct vr_packet *vrPkt = AllocateVrPacketNonOwned();
+
+    struct vr_packet *clonedVrPkt = win_pclone(vrPkt);
+    assert_null(clonedVrPkt);
+
+    FreeVrPacket(vrPkt);
+}
+
+void
+Test_win_pclone_ReturnsNullWhenSecondCloneFails(void **state)
+{
+    WinPacketRawAllocateClone_Callback = Failing_WinPacketRawAllocateClone;
+    Fake_WinPacketRawAllocateClone_SetFailureOnNthCall(2);
+
+    struct vr_packet *vrPkt = AllocateVrPacketNonOwned();
+
+    struct vr_packet *clonedVrPkt = win_pclone(vrPkt);
+    assert_null(clonedVrPkt);
+
+    FreeVrPacket(vrPkt);
+}
+
+void
+Test_win_pclone_ReturnsNullWhenWrapperAllocationFails(void **state)
+{
+    WinPacketRawAllocateClone_Callback = Succeeding_WinPacketRawAllocateClone;
+    WinRawAllocate_Callback = Failing_WinRawAllocate;
+
+    struct vr_packet *vrPkt = AllocateVrPacketNonOwned();
+
+    struct vr_packet *clonedVrPkt = win_pclone(vrPkt);
+    assert_null(clonedVrPkt);
+
+    FreeVrPacket(vrPkt);
+
+    WinRawAllocate_Callback = Saved_WinRawAllocate;
+}
+
+void
+Test_win_pclone_ReturnsPacketWhenCloneSucceeds(void **state)
+{
+    WinPacketRawAllocateClone_Callback = Succeeding_WinPacketRawAllocateClone;
+    WinRawAllocate_Callback = Succeeding_WinRawAllocate;
+
+    struct vr_packet *vrPkt = AllocateVrPacketNonOwned();
+    vrPkt->vp_type = 1;
+    PWIN_PACKET originalWinPkt = GetWinPacketFromVrPacket(vrPkt);
+
+    struct vr_packet *clonedVrPkt = win_pclone(vrPkt);
+    assert_non_null(clonedVrPkt);
+
+    assert_int_equal(WinPacketRawGetChildCountOf(originalWinPkt), 2);
+    assert_ptr_equal(GetParent_(vrPkt), originalWinPkt);
+    assert_ptr_equal(GetParent_(clonedVrPkt), originalWinPkt);
+    assert_int_equal(clonedVrPkt->vp_type, 1);
+
+    FreeVrPacket(vrPkt);
+    FreeVrPacket(clonedVrPkt);
+}
+
+#define win_pclone_UnitTest_(p, f) cmocka_unit_test_setup_teardown(p##f, p##SetUp, p##TearDown)
+#define win_pclone_UnitTest(f) win_pclone_UnitTest_(Test_win_pclone_, f)
+
+int main(void) {
+    const struct CMUnitTest tests[] = {
+        win_pclone_UnitTest(ReturnsNullWhenNullIsPassed),
+        win_pclone_UnitTest(ReturnsNullWhenFirstCloneFails),
+        win_pclone_UnitTest(ReturnsNullWhenSecondCloneFails),
+        win_pclone_UnitTest(ReturnsNullWhenWrapperAllocationFails),
+        win_pclone_UnitTest(ReturnsPacketWhenCloneSucceeds),
+    };
+    return cmocka_run_group_tests(tests, NULL, NULL);
+}

test/windows/test_win_pfree.c

@@ -0,0 +1,38 @@
+/*
+ * test_win_pclone.c
+ *
+ * Copyright (c) 2018 Juniper Networks, Inc. All rights reserved.
+ */
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <setjmp.h>
+#include <cmocka.h>
+
+#include "vr_packet.h"
+#include "win_packet.h"
+#include "fake_win_packet.h"
+
+extern void win_pfree(struct vr_packet *pkt, unsigned short reason);
+
+void Test_win_pfree_AssertsWhenVrPacketIsNull(void** state) {
+    expect_assert_failure(win_pfree(NULL, 0));
+}
+
+void Test_win_pfree_FreeSuccessful(void** state) {
+    PVR_PACKET_WRAPPER pkt = test_calloc(1, sizeof(*pkt));
+    pkt->WinPacket = Fake_WinPacketAllocateNonOwned();
+    struct vr_packet *vrPkt = &pkt->VrPacket;
+
+    win_pfree(vrPkt, 0);
+}
+
+
+int main(void) {
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test(Test_win_pfree_AssertsWhenVrPacketIsNull),
+        cmocka_unit_test(Test_win_pfree_FreeSuccessful),
+    };
+    return cmocka_run_group_tests(tests, NULL, NULL);
+}

windows/SConscript

@@ -15,6 +15,8 @@ env.Append(CPPFLAGS = '/WX')
 # Files should be added when needed to this list
 sources = [
     'win_packet.c',
+    'win_pclone.c',
+    'win_pfree.c',
 ]
 
 env.StaticLibrary('win_packet', source = sources)

windows/vRouter.vcxproj

@@ -522,6 +522,15 @@
     <ClCompile Include="win_packet_raw.c">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
     </ClCompile>
+    <ClCompile Include="win_pclone.c">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="win_pfree.c">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="win_memory.c">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <Inf Include="vRouter.inf" />

windows/vRouter.vcxproj.filters

@@ -297,6 +297,15 @@
     <ClCompile Include="windows\win_packet_raw.c">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="windows\win_pclone.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="windows\win_pfree.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="windows\win_memory.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <Inf Include="windows\vRouter.inf">