Adding upstream version 18.2.2.upstream/18.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 11400 insertions, 0 deletions

diff --git a/src/libkmip/tests.c b/src/libkmip/tests.c
new file mode 100644
index 000000000..c48222923
--- /dev/null
+++ b/src/libkmip/tests.c
@@ -0,0 +1,11400 @@
+/* Copyright (c) 2018 The Johns Hopkins University/Applied Physics Laboratory
+ * All Rights Reserved.
+ *
+ * This file is dual licensed under the terms of the Apache 2.0 License and
+ * the BSD 3-Clause License. See the LICENSE file in the root of this
+ * repository for more information.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "kmip.h"
+
+
+
+#define TEST_PASSED(A, B)       \
+do                              \
+{                               \
+    printf("PASS - %s\n", (B)); \
+    (A)->tests_passed++;        \
+    return(0);                  \
+} while(0)
+
+#define TEST_FAILED(A, B, C)               \
+do                                         \
+{                                          \
+    printf("FAIL - %s @ L%d\n", (B), (C)); \
+    (A)->tests_failed++;                   \
+    return(1);                             \
+} while(0)
+
+#define TRACK_TEST(A) ((A)->test_count++)
+
+
+typedef struct test_tracker
+{
+    uint16 test_count;
+    uint16 tests_failed;
+    uint16 tests_passed;
+} TestTracker;
+
+
+int
+report_encoding_test_result(
+    TestTracker *tracker,
+    struct kmip *ctx,
+    const uint8 *expected,
+    const uint8 *observed,
+    int result,
+    const char *function)
+{
+    if(result == KMIP_OK)
+    {
+        for(size_t i = 0; i < ctx->size; i++)
+        {
+            if(expected[i] != observed[i])
+            {
+                printf("FAIL - %s\n", function);
+                printf("- byte mismatch at: %zu (exp: %X, obs: %X)\n",
+                       i, expected[i], observed[i]);
+                for(size_t j = 0; j < ctx->size; j++)
+                {
+                    printf("- %zu: %X - %X\n", j, expected[j], observed[j]);
+                }
+                tracker->tests_failed++;
+                return(1);
+            }
+        }
+        
+        TEST_PASSED(tracker, function);
+    }
+    else
+    {
+        printf("FAIL - %s\n", function);
+        if(result == KMIP_ERROR_BUFFER_FULL)
+        {
+            printf("- context buffer is full\n");
+        }
+        kmip_print_stack_trace(ctx);
+        tracker->tests_failed++;
+        return(1);
+    }
+}
+
+int
+report_decoding_test_result(
+    TestTracker *tracker,
+    struct kmip *ctx,
+    int comparison,
+    int result,
+    const char *function)
+{
+    if(result == KMIP_OK)
+    {
+        if(comparison)
+        {
+            TEST_PASSED(tracker, function);
+        }
+        else
+        {
+            printf("FAIL - %s\n", function);
+            printf("- compared objects are not identical\n");
+            tracker->tests_failed++;
+            return(1);
+        }
+    }
+    else
+    {
+        printf("FAIL - %s\n", function);
+        if(result == KMIP_ERROR_BUFFER_FULL)
+        {
+            printf("- context buffer is underfull\n");
+        }
+        kmip_print_stack_trace(ctx);
+        tracker->tests_failed++;
+        return(1);
+    }
+}
+
+int
+report_result(TestTracker *tracker, int observed, int expected, const char *function)
+{
+    if(observed == expected)
+    {
+        TEST_PASSED(tracker, function);
+    }
+    else
+    {
+        printf("FAIL - %s\n", function);
+        tracker->tests_failed++;
+        return(1);
+    }
+}
+
+int
+test_linked_list_push(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    LinkedList list = {0};
+
+    LinkedListItem a = {0};
+    LinkedListItem b = {0};
+    LinkedListItem c = {0};
+
+    if(list.head != NULL || list.tail != NULL || list.size != 0)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_linked_list_push(&list, &a);
+
+    if(list.head != &a || list.tail != &a || list.size != 1)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_linked_list_push(&list, &b);
+
+    if(list.head != &b || list.tail != &a || list.size != 2)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_linked_list_push(&list, &c);
+
+    if(list.head != &c || list.tail != &a || list.size != 3)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    LinkedListItem *curr = list.head;
+    if(curr != &c || curr->next != &b || curr->prev != NULL)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    curr = curr->next;
+    if(curr != &b || curr->next != &a || curr->prev != &c)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    curr = curr->next;
+    if(curr != &a || curr->next != NULL || curr->prev != &b)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_linked_list_pop(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    LinkedList list = {0};
+
+    if(list.head != NULL || list.tail != NULL || list.size != 0)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    LinkedListItem *item = kmip_linked_list_pop(&list);
+
+    if(item != NULL || list.head != NULL || list.tail != NULL || list.size != 0)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    LinkedListItem a = {0};
+    LinkedListItem b = {0};
+    LinkedListItem c = {0};
+
+    a.next = &b;
+    a.prev = NULL;
+    b.next = &c;
+    b.prev = &a;
+    c.next = NULL;
+    c.prev = &b;
+
+    list.head = &a;
+    list.tail = &c;
+    list.size = 3;
+
+    item = kmip_linked_list_pop(&list);
+
+    if(item != &a || list.head != &b || list.tail != &c || list.size != 2)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    item = kmip_linked_list_pop(&list);
+
+    if(item != &b || list.head != &c || list.tail != &c || list.size != 1)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    item = kmip_linked_list_pop(&list);
+
+    if(item != &c || list.head != NULL || list.tail != NULL || list.size != 0)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_linked_list_enqueue(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    LinkedList list = {0};
+
+    LinkedListItem a = {0};
+    LinkedListItem b = {0};
+    LinkedListItem c = {0};
+
+    if(list.head != NULL || list.tail != NULL || list.size != 0)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_linked_list_enqueue(&list, &a);
+
+    if(list.head != &a || list.tail != &a || list.size != 1)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_linked_list_enqueue(&list, &b);
+
+    if(list.head != &a || list.tail != &b || list.size != 2)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_linked_list_enqueue(&list, &c);
+
+    if(list.head != &a || list.tail != &c || list.size != 3)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    LinkedListItem *curr = list.head;
+    if(curr != &a || curr->next != &b || curr->prev != NULL)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    curr = curr->next;
+    if(curr != &b || curr->next != &c || curr->prev != &a)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    curr = curr->next;
+    if(curr != &c || curr->next != NULL || curr->prev != &b)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_buffer_full_and_resize(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[40] = {
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 too_small[30] = {0};
+    uint8 large_enough[40] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, too_small, ARRAY_LENGTH(too_small), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    int result = kmip_encode_protocol_version(&ctx, &pv);
+    
+    if(result == KMIP_ERROR_BUFFER_FULL)
+    {
+        kmip_reset(&ctx);
+        kmip_set_buffer(&ctx, large_enough, ARRAY_LENGTH(large_enough));
+        
+        result = kmip_encode_protocol_version(&ctx, &pv);
+        result = report_encoding_test_result(
+            tracker,
+            &ctx,
+            expected,
+            large_enough,
+            result,
+            __func__);
+        
+        kmip_destroy(&ctx);
+        
+        return(result);
+    }
+    else
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- expected buffer full\n");
+        
+        kmip_destroy(&ctx);
+        tracker->tests_failed++;
+        return(1);
+    }
+}
+
+int
+test_is_tag_next(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[3] = {0x42, 0x00, 0x08};
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 *before = ctx.index;
+    int result = 0;
+    
+    if(kmip_is_tag_next(&ctx, KMIP_TAG_ATTRIBUTE) == KMIP_FALSE)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- expected tag is not next\n");
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    uint8 *after = ctx.index;
+    
+    if(before != after)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- tag checking modifies context buffer index\n");
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    kmip_destroy(&ctx);
+    
+    if(result == 0)
+    {
+        printf("PASS - %s\n", __func__);
+        tracker->tests_passed++;
+    }
+    
+    return(result);
+}
+
+int
+test_get_num_items_next(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[168] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, 
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, 
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, 
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00        
+    };
+
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 *before = ctx.index;
+    int result = 0;
+    int count = 0;
+    
+    count = kmip_get_num_items_next(&ctx, KMIP_TAG_ATTRIBUTE);
+    if(count != 3)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- expected item count not found (exp. 3, obs. %d)\n",
+               count);
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    uint8 *after = ctx.index;
+    
+    if(before != after)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- item count checking modifies context buffer index\n");
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    kmip_destroy(&ctx);
+    
+    if(result == 0)
+    {
+        printf("PASS - %s\n", __func__);
+        tracker->tests_passed++;
+    }
+    
+    return(result);
+}
+
+int
+test_get_num_items_next_with_partial_item(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[136] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, 
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72 
+    };
+
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 *before = ctx.index;
+    int result = 0;
+    int count = 0;
+    
+    count = kmip_get_num_items_next(&ctx, KMIP_TAG_ATTRIBUTE);
+    if(count != 2)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- expected item count not found (exp. 2, obs. %d)\n",
+               count);
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    uint8 *after = ctx.index;
+    
+    if(before != after)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- item count checking modifies context buffer index\n");
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    kmip_destroy(&ctx);
+    
+    if(result == 0)
+    {
+        printf("PASS - %s\n", __func__);
+        tracker->tests_passed++;
+    }
+    
+    return(result);
+}
+
+int
+test_get_num_items_next_with_mismatch_item(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[80] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x20, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72 
+    };
+
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 *before = ctx.index;
+    int result = 0;
+    int count = 0;
+    
+    count = kmip_get_num_items_next(&ctx, KMIP_TAG_ATTRIBUTE);
+    if(count != 1)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- expected item count not found (exp. 1, obs. %d)\n",
+               count);
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    uint8 *after = ctx.index;
+    
+    if(before != after)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- item count checking modifies context buffer index\n");
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    kmip_destroy(&ctx);
+    
+    if(result == 0)
+    {
+        printf("PASS - %s\n", __func__);
+        tracker->tests_passed++;
+    }
+    
+    return(result);
+}
+
+int
+test_get_num_items_next_with_no_matches(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[80] = {
+        0x42, 0x00, 0x20, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x20, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72 
+    };
+
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 *before = ctx.index;
+    int result = 0;
+    int count = 0;
+    
+    count = kmip_get_num_items_next(&ctx, KMIP_TAG_ATTRIBUTE);
+    if(count != 0)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- expected item count not found (exp. 0, obs. %d)\n",
+               count);
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    uint8 *after = ctx.index;
+    
+    if(before != after)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- item count checking modifies context buffer index\n");
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    kmip_destroy(&ctx);
+    
+    if(result == 0)
+    {
+        printf("PASS - %s\n", __func__);
+        tracker->tests_passed++;
+    }
+    
+    return(result);
+}
+
+int
+test_get_num_items_next_with_non_structures(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[144] = {
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x26,
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, 
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x11, 0x11, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x25,
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, 
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x11, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, 
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00
+    };
+
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 *before = ctx.index;
+    int result = 0;
+    int count = 0;
+    
+    count = kmip_get_num_items_next(&ctx, KMIP_TAG_UNIQUE_IDENTIFIER);
+    if(count != 3)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- expected item count not found (exp. 3, obs. %d)\n",
+               count);
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    uint8 *after = ctx.index;
+    
+    if(before != after)
+    {
+        printf("FAIL - %s\n", __func__);
+        printf("- item count checking modifies context buffer index\n");
+        tracker->tests_failed++;
+        result = 1;
+    }
+    
+    kmip_destroy(&ctx);
+    
+    if(result == 0)
+    {
+        printf("PASS - %s\n", __func__);
+        tracker->tests_passed++;
+    }
+    
+    return(result);
+}
+
+int
+test_buffer_bytes_left(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 a[1] = {0x42};
+    uint8 b[3] = {0x42, 0x00, 0x08};
+    uint8 c[5] = {0x42, 0x00, 0x53, 0x01, 0x00};
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, a, ARRAY_LENGTH(a), KMIP_1_0);
+
+    if(BUFFER_BYTES_LEFT(&ctx) != 1)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_destroy(&ctx);
+    kmip_init(&ctx, b, ARRAY_LENGTH(b), KMIP_1_0);
+
+    if(BUFFER_BYTES_LEFT(&ctx) != 3)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_destroy(&ctx);
+    kmip_init(&ctx, c, ARRAY_LENGTH(c), KMIP_1_0);
+
+    if(BUFFER_BYTES_LEFT(&ctx) != 5)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_destroy(&ctx);
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_get_num_attributes_next(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* Need to build an encoding with one of each type of support
+       attribute. Verify that this function returns the correct
+       count.
+
+       Need to build an encoding with bad attribute length? Handle
+       weird corner cases?
+    */
+    TEST_FAILED(tracker, __func__, __LINE__);
+}
+
+int
+test_peek_tag(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* Build an encoding with an arbitrary tag value. Verify that this
+       function reads and returns this tag value without changing the
+       context buffer.
+    */
+
+    uint8 underfull_encoding[1] = {0x42};
+    uint8 full_encoding[3] = {0x42, 0x00, 0x08};
+    uint8 overfull_encoding[5] = {0x42, 0x00, 0x53, 0x01, 0x00};
+
+    uint32 tag = 0;
+    uint8 *prev_buffer = NULL;
+    uint8 *prev_index = NULL;
+    size_t prev_size = 0;
+    KMIP ctx = {0};
+    kmip_init(&ctx, underfull_encoding, ARRAY_LENGTH(underfull_encoding), KMIP_1_0);
+
+    prev_buffer = ctx.buffer;
+    prev_index = ctx.index;
+    prev_size = ctx.size;
+    tag = kmip_peek_tag(&ctx);
+    if(tag != 0 || ctx.buffer != prev_buffer || ctx.index != prev_index || ctx.size != prev_size)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_destroy(&ctx);
+    kmip_init(&ctx, full_encoding, ARRAY_LENGTH(full_encoding), KMIP_1_0);
+
+    prev_buffer = ctx.buffer;
+    prev_index = ctx.index;
+    prev_size = ctx.size;
+    tag = kmip_peek_tag(&ctx);
+    if(tag != KMIP_TAG_ATTRIBUTE || ctx.buffer != prev_buffer || ctx.index != prev_index || ctx.size != prev_size)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_destroy(&ctx);
+    kmip_init(&ctx, overfull_encoding, ARRAY_LENGTH(overfull_encoding), KMIP_1_0);
+
+    prev_buffer = ctx.buffer;
+    prev_index = ctx.index;
+    prev_size = ctx.size;
+    tag = kmip_peek_tag(&ctx);
+    if(tag != KMIP_TAG_NAME || ctx.buffer != prev_buffer || ctx.index != prev_index || ctx.size != prev_size)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_destroy(&ctx);
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_is_attribute_tag(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    if(!kmip_is_attribute_tag(KMIP_TAG_UNIQUE_IDENTIFIER))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_NAME))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_OBJECT_TYPE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CRYPTOGRAPHIC_ALGORITHM))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CRYPTOGRAPHIC_LENGTH))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CRYPTOGRAPHIC_PARAMETERS))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CRYPTOGRAPHIC_DOMAIN_PARAMETERS))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CERTIFICATE_TYPE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CERTIFICATE_LENGTH))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_X509_CERTIFICATE_IDENTIFIER))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_X509_CERTIFICATE_SUBJECT))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_X509_CERTIFICATE_ISSUER))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CERTIFICATE_IDENTIFIER))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CERTIFICATE_SUBJECT))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CERTIFICATE_ISSUER))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_DIGITAL_SIGNATURE_ALGORITHM))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_DIGEST))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_OPERATION_POLICY_NAME))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CRYPTOGRAPHIC_USAGE_MASK))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_LEASE_TIME))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_USAGE_LIMITS))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_STATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_INITIAL_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_ACTIVATION_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_PROCESS_START_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_PROTECT_STOP_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_DEACTIVATION_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_DESTROY_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_COMPROMISE_OCCURRENCE_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_COMPROMISE_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_REVOCATION_REASON))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_ARCHIVE_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_OBJECT_GROUP))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_FRESH))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_LINK))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_APPLICATION_SPECIFIC_INFORMATION))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_CONTACT_INFORMATION))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_LAST_CHANGE_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_ALTERNATIVE_NAME))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_KEY_VALUE_PRESENT))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_KEY_VALUE_LOCATION))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_ORIGINAL_CREATION_DATE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_RANDOM_NUMBER_GENERATOR))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_PKCS_12_FRIENDLY_NAME))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_DESCRIPTION))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_COMMENT))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_SENSITIVE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_ALWAYS_SENSITIVE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_EXTRACTABLE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_NEVER_EXTRACTABLE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_is_attribute_tag(KMIP_TAG_KEY_FORMAT_TYPE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_is_attribute_tag(KMIP_TAG_REQUEST_MESSAGE))
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_get_enum_string_index(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    if(kmip_get_enum_string_index(KMIP_TAG_UNIQUE_IDENTIFIER) != 0)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_NAME) != 1)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_OBJECT_TYPE) != 2)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CRYPTOGRAPHIC_ALGORITHM) != 3)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CRYPTOGRAPHIC_LENGTH) != 4)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CRYPTOGRAPHIC_PARAMETERS) != 5)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CRYPTOGRAPHIC_DOMAIN_PARAMETERS) != 6)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CERTIFICATE_TYPE) != 7)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CERTIFICATE_LENGTH) != 8)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_X509_CERTIFICATE_IDENTIFIER) != 9)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_X509_CERTIFICATE_SUBJECT) != 10)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_X509_CERTIFICATE_ISSUER) != 11)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CERTIFICATE_IDENTIFIER) != 12)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CERTIFICATE_SUBJECT) != 13)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CERTIFICATE_ISSUER) != 14)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_DIGITAL_SIGNATURE_ALGORITHM) != 15)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_DIGEST) != 16)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_OPERATION_POLICY_NAME) != 17)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CRYPTOGRAPHIC_USAGE_MASK) != 18)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_LEASE_TIME) != 19)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_USAGE_LIMITS) != 20)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_STATE) != 21)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_INITIAL_DATE) != 22)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_ACTIVATION_DATE) != 23)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_PROCESS_START_DATE) != 24)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_PROTECT_STOP_DATE) != 25)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_DEACTIVATION_DATE) != 26)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_DESTROY_DATE) != 27)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_COMPROMISE_OCCURRENCE_DATE) != 28)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_COMPROMISE_DATE) != 29)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_REVOCATION_REASON) != 30)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_ARCHIVE_DATE) != 31)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_OBJECT_GROUP) != 32)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_FRESH) != 33)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_LINK) != 34)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_APPLICATION_SPECIFIC_INFORMATION) != 35)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_CONTACT_INFORMATION) != 36)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_LAST_CHANGE_DATE) != 37)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_ALTERNATIVE_NAME) != 38)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_KEY_VALUE_PRESENT) != 39)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_KEY_VALUE_LOCATION) != 40)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_ORIGINAL_CREATION_DATE) != 41)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_RANDOM_NUMBER_GENERATOR) != 42)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_PKCS_12_FRIENDLY_NAME) != 43)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_DESCRIPTION) != 44)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_COMMENT) != 45)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_SENSITIVE) != 46)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_ALWAYS_SENSITIVE) != 47)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_EXTRACTABLE) != 48)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_NEVER_EXTRACTABLE) != 49)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(KMIP_TAG_KEY_FORMAT_TYPE) != 50)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_get_enum_string_index(-1) != 51)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_check_enum_value_protection_storage_masks(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    enum kmip_version v = KMIP_2_0;
+    enum tag t = KMIP_TAG_PROTECTION_STORAGE_MASK;
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_SOFTWARE) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_HARDWARE) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_PROCESSOR) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_SYSTEM) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_OFF_SYSTEM) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_HYPERVISOR) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_OPERATING_SYSTEM) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_CONTAINER) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_PREMISES) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_OFF_PREMISES) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_SELF_MANAGED) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_OUTSOURCED) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_VALIDATED) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_SAME_JURISDICTION) != KMIP_OK)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    v = KMIP_1_4;
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_SOFTWARE) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_HARDWARE) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_PROCESSOR) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_SYSTEM) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_OFF_SYSTEM) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_HYPERVISOR) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_OPERATING_SYSTEM) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_CONTAINER) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_ON_PREMISES) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_OFF_PREMISES) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_SELF_MANAGED) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_OUTSOURCED) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_VALIDATED) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, KMIP_PROTECT_SAME_JURISDICTION) != KMIP_INVALID_FOR_VERSION)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    if(kmip_check_enum_value(v, t, -1) != KMIP_ENUM_MISMATCH)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_init_protocol_version(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    kmip_init_protocol_version(NULL, KMIP_1_0);
+
+    ProtocolVersion pv = {0};
+
+    if(pv.major != 0)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(pv.minor != 0)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    kmip_init_protocol_version(&pv, KMIP_1_0);
+
+    if(pv.major != 1)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(pv.minor != 0)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    kmip_init_protocol_version(&pv, KMIP_1_1);
+
+    if(pv.major != 1)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(pv.minor != 1)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    kmip_init_protocol_version(&pv, KMIP_1_2);
+
+    if(pv.major != 1)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(pv.minor != 2)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    kmip_init_protocol_version(&pv, KMIP_1_3);
+
+    if(pv.major != 1)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(pv.minor != 3)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    kmip_init_protocol_version(&pv, KMIP_1_4);
+
+    if(pv.major != 1)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(pv.minor != 4)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    kmip_init_protocol_version(&pv, KMIP_2_0);
+
+    if(pv.major != 2)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(pv.minor != 0)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_init_request_batch_item(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    kmip_init_request_batch_item(NULL);
+
+    RequestBatchItem rbi = {0};
+
+    if(rbi.operation != 0)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(rbi.unique_batch_item_id != NULL)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(rbi.request_payload != NULL)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(rbi.ephemeral != 0)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    kmip_init_request_batch_item(&rbi);
+
+    if(rbi.operation != 0)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(rbi.unique_batch_item_id != NULL)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(rbi.request_payload != NULL)
+        TEST_FAILED(tracker, __func__, __LINE__);
+    if(rbi.ephemeral != KMIP_UNSET)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_print_attributes(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* For now this will probably be left as a placeholder for a
+       future test. Ideally the print functions would output to
+       an arbitrary buffer so that we can verify that they are
+       correctly displaying structure content and formatting.
+       Since they currently use printf directly, this may be hard
+       to do in the short term.
+    */
+    TEST_FAILED(tracker, __func__, __LINE__);
+}
+
+int
+test_free_attributes(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* Build a dynamically allocated Attributes structure. Free it
+       with this function. Verify that all internal pointers and
+       fields are correctly nullified.
+
+       Ideally, hook into the free function managed by the context
+       and use that hook to verify that the correct free calls are
+       made on the internal Attributes structure pointers. This
+       may require more infrastructure work than currently exists.
+    */
+    TEST_FAILED(tracker, __func__, __LINE__);
+}
+
+int
+test_compare_attributes(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* Build two separate identical Attributes structures. Compare
+       them with this function and confirm they match.
+
+       Build two separate different Attributes structures. Compare
+       them with this function and confirm they do not match. This
+       may require multiple rounds, changing different parts of the
+       underlying Attributes structure. It may make more sense to
+       split this into multiple test functions.
+    */
+    TEST_FAILED(tracker, __func__, __LINE__);
+}
+
+int
+test_deep_copy_int32(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    int32 expected = 42;
+    int32 *observed = NULL;
+
+    observed = kmip_deep_copy_int32(NULL, NULL);
+    if(observed != NULL)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, NULL, 0, KMIP_1_0);
+
+    observed = kmip_deep_copy_int32(&ctx, NULL);
+    if(observed != NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    observed = kmip_deep_copy_int32(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(*observed != expected)
+    {
+        kmip_print_integer(expected);
+        kmip_print_integer(*observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    ctx.free_func(ctx.state, observed);
+    kmip_destroy(&ctx);
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_deep_copy_text_string(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    TextString expected = {0};
+    expected.value = "example";
+    expected.size = 7;
+    TextString *observed = NULL;
+
+    observed = kmip_deep_copy_text_string(NULL, NULL);
+    if(observed != NULL)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, NULL, 0, KMIP_1_0);
+
+    observed = kmip_deep_copy_text_string(&ctx, NULL);
+    if(observed != NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    observed = kmip_deep_copy_text_string(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_text_string(&expected, observed))
+    {
+        kmip_print_text_string(1, "Name Value", &expected);
+        kmip_print_text_string(1, "Name Value", observed);
+        kmip_free_text_string(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_text_string(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+    kmip_destroy(&ctx);
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_deep_copy_name(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    TextString value = {0};
+    value.value = "example";
+    value.size = 7;
+    Name expected = {0};
+    expected.value = &value;
+    expected.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+    Name *observed = NULL;
+
+    observed = kmip_deep_copy_name(NULL, NULL);
+    if(observed != NULL)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, NULL, 0, KMIP_1_0);
+
+    observed = kmip_deep_copy_name(&ctx, NULL);
+    if(observed != NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    observed = kmip_deep_copy_name(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_name(&expected, observed))
+    {
+        kmip_print_name(1, &expected);
+        kmip_print_name(1, observed);
+        kmip_free_name(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_name(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+    kmip_destroy(&ctx);
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_deep_copy_attribute(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    Attribute expected = {0};
+    kmip_init_attribute(&expected);
+    Attribute *observed = NULL;
+
+    observed = kmip_deep_copy_attribute(NULL, NULL);
+    if(observed != NULL)
+        TEST_FAILED(tracker, __func__, __LINE__);
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, NULL, 0, KMIP_1_0);
+
+    observed = kmip_deep_copy_attribute(&ctx, NULL);
+    if(observed != NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    /* Test deep copying an "empty" attribute. */
+    observed = kmip_deep_copy_attribute(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_attribute(&expected, observed))
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, observed);
+        kmip_free_attribute(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_attribute(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+
+    /* Test deep copying a Unique Identifier attribute. */
+    TextString uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    expected.type = KMIP_ATTR_UNIQUE_IDENTIFIER;
+    expected.value = &uuid;
+
+    observed = kmip_deep_copy_attribute(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_attribute(&expected, observed))
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, observed);
+        kmip_free_attribute(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_attribute(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+
+    /* Test deep copying an Operation Policy Name attribute. */
+    TextString policy = {0};
+    policy.value = "default";
+    policy.size = 7;
+    expected.type = KMIP_ATTR_OPERATION_POLICY_NAME;
+    expected.value = &policy;
+
+    observed = kmip_deep_copy_attribute(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_attribute(&expected, observed))
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, observed);
+        kmip_free_attribute(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_attribute(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+
+    /* Test deep copying a Name attribute. */
+    TextString name_value = {0};
+    name_value.value = "example";
+    name_value.size = 7;
+    Name name = {0};
+    name.value = &name_value;
+    name.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+    expected.type = KMIP_ATTR_NAME;
+    expected.value = &name;
+
+    observed = kmip_deep_copy_attribute(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_attribute(&expected, observed))
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, observed);
+        kmip_free_attribute(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_attribute(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+
+    /* Test deep copying an Object Type attribute. */
+    enum object_type object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    expected.type = KMIP_ATTR_OBJECT_TYPE;
+    expected.value = &object_type;
+
+    observed = kmip_deep_copy_attribute(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_attribute(&expected, observed))
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, observed);
+        kmip_free_attribute(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_attribute(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+
+    /* Test deep copying a Cryptographic Algorithm attribute. */
+    enum cryptographic_algorithm cryptographic_algorithm = KMIP_CRYPTOALG_AES;
+    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    expected.value = &cryptographic_algorithm;
+
+    observed = kmip_deep_copy_attribute(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_attribute(&expected, observed))
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, observed);
+        kmip_free_attribute(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_attribute(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+
+    /* Test deep copying a Cryptographic Length attribute. */
+    int32 cryptographic_length = 256;
+    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    expected.value = &cryptographic_length;
+
+    observed = kmip_deep_copy_attribute(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_attribute(&expected, observed))
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, observed);
+        kmip_free_attribute(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_attribute(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+
+    /* Test deep copying a Cryptographic Usage Mask attribute. */
+    int32 cryptographic_usage_mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    expected.value = &cryptographic_usage_mask;
+
+    observed = kmip_deep_copy_attribute(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_attribute(&expected, observed))
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, observed);
+        kmip_free_attribute(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_attribute(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+
+    /* Test deep copying a State attribute. */
+    enum state state = KMIP_STATE_ACTIVE;
+    expected.type = KMIP_ATTR_STATE;
+    expected.value = &state;
+
+    observed = kmip_deep_copy_attribute(&ctx, &expected);
+    if(observed == NULL)
+    {
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+    if(!kmip_compare_attribute(&expected, observed))
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, observed);
+        kmip_free_attribute(&ctx, observed);
+        ctx.free_func(ctx.state, observed);
+        kmip_destroy(&ctx);
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_attribute(&ctx, observed);
+    ctx.free_func(ctx.state, observed);
+    kmip_destroy(&ctx);
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_decode_int8_be(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[1] = {0x42};
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    int8 value = 0;
+    
+    int result = kmip_decode_int8_be(&ctx, &value);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        value == 0x42, 
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_int32_be(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[4] = {0x11, 0x22, 0x33, 0x44};
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+
+    int32 expected = 0x11223344;
+    int32 observed = 0;
+    
+    int result = kmip_decode_int32_be(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        observed == expected,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_int64_be(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[8] = {
+        0x01, 0xB6, 0x9B, 0x4B, 0xA5, 0x74, 0x92, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    int64 expected = 0x01B69B4BA5749200;
+    int64 observed = 0;
+    
+    int result = kmip_decode_int64_be(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        observed == expected,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_integer(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[16] = {
+        0x42, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[16] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    int result = kmip_encode_integer(&ctx, KMIP_TAG_DEFAULT, 8);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_integer(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00
+    };
+
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    int32 expected = 8;
+    int32 observed = 0;
+    
+    int result = kmip_decode_integer(&ctx, KMIP_TAG_DEFAULT, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        observed == expected,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_long(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[16] = {
+        0x42, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08,
+        0x01, 0xB6, 0x9B, 0x4B, 0xA5, 0x74, 0x92, 0x00
+    };
+    
+    uint8 observed[16] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    int result = kmip_encode_long(&ctx, KMIP_TAG_DEFAULT, 123456789000000000);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_long(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08,
+        0x01, 0xB6, 0x9B, 0x4B, 0xA5, 0x74, 0x92, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    int64 expected = 0x01B69B4BA5749200;
+    int64 observed = 0;
+    
+    int result = kmip_decode_long(&ctx, KMIP_TAG_DEFAULT, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        observed == expected,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_enum(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[16] = {
+        0x42, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[16] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    int result = kmip_encode_enum(&ctx, KMIP_TAG_DEFAULT, KMIP_CRYPTOALG_AES);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_enum(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    enum cryptographic_algorithm expected = KMIP_CRYPTOALG_AES;
+    enum cryptographic_algorithm observed = 0;
+    
+    int result = kmip_decode_enum(&ctx, KMIP_TAG_DEFAULT, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        observed == expected,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_bool(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[16] = {
+        0x42, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+    };
+    
+    uint8 observed[16] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    int result = kmip_encode_bool(&ctx, KMIP_TAG_DEFAULT, KMIP_TRUE);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_bool(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    bool32 expected = KMIP_TRUE;
+    bool32 observed = 0;
+    
+    int result = kmip_decode_bool(&ctx, KMIP_TAG_DEFAULT, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        observed == expected,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_text_string(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[24] = {
+        0x42, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0B,
+        0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F,
+        0x72, 0x6C, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[24] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+
+    struct text_string example = {0};
+    example.value = "Hello World";
+    example.size = 11;
+    
+    int result = kmip_encode_text_string(&ctx, KMIP_TAG_DEFAULT, &example);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_text_string(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[24] = {
+        0x42, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0B,
+        0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F,
+        0x72, 0x6C, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+
+    struct text_string expected = {0};
+    expected.value = "Hello World";
+    expected.size = 11;
+    struct text_string observed = {0};
+    
+    int result = kmip_decode_text_string(&ctx, KMIP_TAG_DEFAULT, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_text_string(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_text_string(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_byte_string(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[16] = {
+        0x42, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03,
+        0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[16] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    uint8 str[3] = {0x01, 0x02, 0x03};
+    
+    struct byte_string example = {0};
+    example.value = str;
+    example.size = 3;
+    
+    int result = kmip_encode_byte_string(&ctx, KMIP_TAG_DEFAULT, &example);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_byte_string(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03,
+        0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+
+    uint8 str[3] = {0x01, 0x02, 0x03};
+    
+    struct byte_string expected = {0};
+    expected.value = str;
+    expected.size = 3;
+    struct byte_string observed = {0};
+    
+    int result = kmip_decode_byte_string(&ctx, KMIP_TAG_DEFAULT, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_byte_string(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_byte_string(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_date_time(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[16] = {
+        0x42, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x47, 0xDA, 0x67, 0xF8
+    };
+    
+    uint8 observed[16] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    int result = kmip_encode_date_time(&ctx, KMIP_TAG_DEFAULT, 1205495800);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_date_time(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x47, 0xDA, 0x67, 0xF8
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint64 expected = 1205495800;
+    uint64 observed = 0;
+    
+    int result = kmip_decode_date_time(&ctx, KMIP_TAG_DEFAULT, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        observed == expected,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_interval(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[16] = {
+        0x42, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x0D, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[16] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    int result = kmip_encode_interval(&ctx, KMIP_TAG_DEFAULT, 864000);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_interval(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x0D, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint32 expected = 864000;
+    uint32 observed = 0;
+    
+    int result = kmip_decode_interval(&ctx, KMIP_TAG_DEFAULT, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        observed == expected,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_name(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[48] = {
+        0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28,
+        0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09,
+        0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65,
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[48] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string value = {0};
+    value.value = "Template1";
+    value.size = 9;
+    
+    struct name n = {0};
+    n.value = &value;
+    n.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+    
+    int result = kmip_encode_name(&ctx, &n);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_name(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[48] = {
+        0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28,
+        0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09,
+        0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65,
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string value = {0};
+    value.value = "Template1";
+    value.size = 9;
+    
+    struct name expected = {0};
+    expected.value = &value;
+    expected.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+    struct name observed = {0};
+    
+    int result = kmip_decode_name(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_name(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_name(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_protection_storage_masks(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Protection Storage Masks
+    *      Protection Storage Mask
+    *          Software
+    *          Hardware
+    *          On Processor
+    *          On System
+    *          Off System
+    *          Hypervisor
+    *          Operating System
+    *          Container
+    *          On Premises
+    *          Off Premises
+    *          Self Managed
+    *          Outsourced
+    *          Validated
+    *          Same Jurisdiction
+    *      Protection Storage Mask
+    *          Software
+    *          Hardware
+    */
+    uint8 expected[40] = {
+        0x42, 0x01, 0x5F, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x3F, 0xFF, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
+    };
+
+    uint8 observed[40] = {0};
+    KMIP ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    LinkedList list = {0};
+    LinkedListItem item_1 = {0};
+    int32 mask_1 = 0x3FFF;
+    item_1.data = &mask_1;
+
+    LinkedListItem item_2 = {0};
+    int32 mask_2 = 0x0003;
+    item_2.data = &mask_2;
+
+    kmip_linked_list_enqueue(&list, &item_1);
+    kmip_linked_list_enqueue(&list, &item_2);
+
+    ProtectionStorageMasks psm = {0};
+    psm.masks = &list;
+
+    int result = kmip_encode_protection_storage_masks(&ctx, &psm);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_decode_protection_storage_masks(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Protection Storage Masks
+    *      Protection Storage Mask
+    *          Software
+    *          Hardware
+    *          On Processor
+    *          On System
+    *          Off System
+    *          Hypervisor
+    *          Operating System
+    *          Container
+    *          On Premises
+    *          Off Premises
+    *          Self Managed
+    *          Outsourced
+    *          Validated
+    *          Same Jurisdiction
+    *      Protection Storage Mask
+    *          Software
+    *          Hardware
+    */
+    uint8 encoding[40] = {
+        0x42, 0x01, 0x5F, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x3F, 0xFF, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    LinkedList list = {0};
+    LinkedListItem item_1 = {0};
+    int32 mask_1 = 0x3FFF;
+    item_1.data = &mask_1;
+
+    LinkedListItem item_2 = {0};
+    int32 mask_2 = 0x0003;
+    item_2.data = &mask_2;
+
+    kmip_linked_list_enqueue(&list, &item_1);
+    kmip_linked_list_enqueue(&list, &item_2);
+
+    ProtectionStorageMasks expected = {0};
+    expected.masks = &list;
+
+    ProtectionStorageMasks observed = {0};
+    int result = kmip_decode_protection_storage_masks(&ctx, &observed);
+    int comparison = kmip_compare_protection_storage_masks(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_protection_storage_masks(1, &expected);
+        kmip_print_protection_storage_masks(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_protection_storage_masks(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_encode_attribute_unique_identifier(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[88] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x50,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x11,
+        0x55, 0x6E, 0x69, 0x71, 0x75, 0x65, 0x20, 0x49,
+        0x64, 0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65,
+        0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38,
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66,
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D,
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63,
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[88] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    struct attribute attr = {0};
+    kmip_init_attribute(&attr);
+    
+    attr.type = KMIP_ATTR_UNIQUE_IDENTIFIER;
+    attr.value = &uuid;
+    
+    int result = kmip_encode_attribute(&ctx, &attr);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_attribute_unique_identifier(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[88] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x50,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x11,
+        0x55, 0x6E, 0x69, 0x71, 0x75, 0x65, 0x20, 0x49,
+        0x64, 0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65,
+        0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38,
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66,
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D,
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63,
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    struct attribute expected = {0};
+    kmip_init_attribute(&expected);
+    expected.type = KMIP_ATTR_UNIQUE_IDENTIFIER;
+    expected.value = &uuid;
+    struct attribute observed = {0};
+    kmip_init_attribute(&observed);
+    
+    int result = kmip_decode_attribute(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_attribute(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_attribute_name(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[72] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x40,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x04,
+        0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x28,
+        0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09,
+        0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65,
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[72] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string value = {0};
+    value.value = "Template1";
+    value.size = 9;
+    
+    struct name n = {0};
+    n.value = &value;
+    n.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+    
+    struct attribute attr = {0};
+    kmip_init_attribute(&attr);
+    
+    attr.type = KMIP_ATTR_NAME;
+    attr.value = &n;
+    
+    int result = kmip_encode_attribute(&ctx, &attr);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_attribute_name(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[72] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x40,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x04,
+        0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x28,
+        0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09,
+        0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65,
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string value = {0};
+    value.value = "Template1";
+    value.size = 9;
+    
+    struct name n = {0};
+    n.value = &value;
+    n.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+    
+    struct attribute expected = {0};
+    kmip_init_attribute(&expected);
+    expected.type = KMIP_ATTR_NAME;
+    expected.value = &n;
+    struct attribute observed = {0};
+    kmip_init_attribute(&observed);
+    
+    int result = kmip_decode_attribute(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_attribute(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_attribute_object_type(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[48] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x28,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x0B,
+        0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x54,
+        0x79, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[48] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    enum object_type t = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    struct attribute attr = {0};
+    kmip_init_attribute(&attr);
+    
+    attr.type = KMIP_ATTR_OBJECT_TYPE;
+    attr.value = &t;
+    
+    int result = kmip_encode_attribute(&ctx, &attr);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_attribute_object_type(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[48] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x28,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x0B,
+        0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x54,
+        0x79, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    enum object_type t = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    struct attribute expected = {0};
+    kmip_init_attribute(&expected);
+    expected.type = KMIP_ATTR_OBJECT_TYPE;
+    expected.value = &t;
+    struct attribute observed = {0};
+    kmip_init_attribute(&observed);
+    
+    int result = kmip_decode_attribute(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_attribute(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_attribute_cryptographic_algorithm(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[56] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17,
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72,
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C,
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00,
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[56] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    enum cryptographic_algorithm a = KMIP_CRYPTOALG_AES;
+    struct attribute attr = {0};
+    kmip_init_attribute(&attr);
+    
+    attr.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    attr.value = &a;
+    
+    int result = kmip_encode_attribute(&ctx, &attr);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_attribute_cryptographic_algorithm(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[56] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17,
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72,
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C,
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00,
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    enum cryptographic_algorithm a = KMIP_CRYPTOALG_AES;
+    struct attribute expected = {0};
+    kmip_init_attribute(&expected);
+    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    expected.value = &a;
+    struct attribute observed = {0};
+    kmip_init_attribute(&observed);
+    
+    int result = kmip_decode_attribute(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_attribute(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_attribute_cryptographic_length(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[56] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14,
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72,
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65,
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[56] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    int32 length = 128;
+    struct attribute attr = {0};
+    kmip_init_attribute(&attr);
+    
+    attr.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    attr.value = &length;
+    
+    int result = kmip_encode_attribute(&ctx, &attr);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_attribute_cryptographic_length(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[56] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14,
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72,
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65,
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    int32 length = 128;
+    struct attribute expected = {0};
+    kmip_init_attribute(&expected);
+    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    expected.value = &length;
+    struct attribute observed = {0};
+    kmip_init_attribute(&observed);
+    
+    int result = kmip_decode_attribute(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_attribute(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_attribute_operation_policy_name(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[56] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x15,
+        0x4F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F,
+        0x6E, 0x20, 0x50, 0x6F, 0x6C, 0x69, 0x63, 0x79,
+        0x20, 0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x07, 0x00, 0x00, 0x00, 0x07,
+        0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x00
+    };
+    
+    uint8 observed[56] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string policy = {0};
+    policy.value = "default";
+    policy.size = 7;
+    
+    struct attribute attr = {0};
+    kmip_init_attribute(&attr);
+    
+    attr.type = KMIP_ATTR_OPERATION_POLICY_NAME;
+    attr.value = &policy;
+    
+    int result = kmip_encode_attribute(&ctx, &attr);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_attribute_operation_policy_name(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[56] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x15,
+        0x4F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F,
+        0x6E, 0x20, 0x50, 0x6F, 0x6C, 0x69, 0x63, 0x79,
+        0x20, 0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x07, 0x00, 0x00, 0x00, 0x07,
+        0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string policy = {0};
+    policy.value = "default";
+    policy.size = 7;
+    
+    struct attribute expected = {0};
+    kmip_init_attribute(&expected);
+    expected.type = KMIP_ATTR_OPERATION_POLICY_NAME;
+    expected.value = &policy;
+    struct attribute observed = {0};
+    kmip_init_attribute(&observed);
+    
+    int result = kmip_decode_attribute(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_attribute(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_attribute_cryptographic_usage_mask(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[56] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18,
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72,
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73,
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B,
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[56] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    struct attribute attr = {0};
+    kmip_init_attribute(&attr);
+    
+    attr.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    attr.value = &mask;
+    
+    int result = kmip_encode_attribute(&ctx, &attr);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_attribute_cryptographic_usage_mask(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[56] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18,
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72,
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73,
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B,
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    struct attribute expected = {0};
+    kmip_init_attribute(&expected);
+    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    expected.value = &mask;
+    struct attribute observed = {0};
+    kmip_init_attribute(&observed);
+    
+    int result = kmip_decode_attribute(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_attribute(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_attribute_state(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[40] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x05, 
+        0x53, 0x74, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[40] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    enum state s = KMIP_STATE_PRE_ACTIVE;
+    struct attribute attr = {0};
+    kmip_init_attribute(&attr);
+    
+    attr.type = KMIP_ATTR_STATE;
+    attr.value = &s;
+    
+    int result = kmip_encode_attribute(&ctx, &attr);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_attribute_state(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[40] = {
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x05, 
+        0x53, 0x74, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    enum state s = KMIP_STATE_PRE_ACTIVE;
+    struct attribute expected = {0};
+    kmip_init_attribute(&expected);
+    expected.type = KMIP_ATTR_STATE;
+    expected.value = &s;
+    struct attribute observed = {0};
+    kmip_init_attribute(&observed);
+    
+    int result = kmip_decode_attribute(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_attribute(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_protocol_version(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[40] = {
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[40] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    int result = kmip_encode_protocol_version(&ctx, &pv);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_protocol_version(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[40] = {
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct protocol_version expected = {0};
+    expected.major = 1;
+    expected.minor = 0;
+    struct protocol_version observed = {0};
+    
+    int result = kmip_decode_protocol_version(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_protocol_version(&expected, &observed),
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_cryptographic_parameters(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[72] = {
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x40,
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[72] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_CBC;
+    cp.padding_method = KMIP_PAD_PKCS5;
+    cp.hashing_algorithm = KMIP_HASH_SHA1;
+    cp.key_role_type = KMIP_ROLE_KEK;
+    
+    int result = kmip_encode_cryptographic_parameters(&ctx, &cp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_cryptographic_parameters(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[72] = {
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x40,
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct cryptographic_parameters expected = {0};
+    kmip_init_cryptographic_parameters(&expected);
+    expected.block_cipher_mode = KMIP_BLOCK_CBC;
+    expected.padding_method = KMIP_PAD_PKCS5;
+    expected.hashing_algorithm = KMIP_HASH_SHA1;
+    expected.key_role_type = KMIP_ROLE_KEK;
+    struct cryptographic_parameters observed = {0};
+    kmip_init_cryptographic_parameters(&observed);
+    
+    int result = kmip_decode_cryptographic_parameters(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_cryptographic_parameters(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_cryptographic_parameters(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_encryption_key_information(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[80] = {
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48,
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35,
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D,
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[80] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    int result = kmip_encode_encryption_key_information(&ctx, &eki);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_encryption_key_information(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[80] = {
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48,
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35,
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D,
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    kmip_init_cryptographic_parameters(&cp);
+    
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information expected = {0};
+    expected.unique_identifier = &uuid;
+    expected.cryptographic_parameters = &cp;
+    
+    struct encryption_key_information observed = {0};
+    
+    int result = kmip_decode_encryption_key_information(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_encryption_key_information(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_encryption_key_information(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_mac_signature_key_information(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[80] = {
+        0x42, 0x00, 0x4E, 0x01, 0x00, 0x00, 0x00, 0x48,
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35,
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D,
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[80] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+
+    struct mac_signature_key_information mski = {0};
+    mski.unique_identifier = &uuid;
+    mski.cryptographic_parameters = &cp;
+    
+    int result = kmip_encode_mac_signature_key_information(&ctx, &mski);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_mac_signature_key_information(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[80] = {
+        0x42, 0x00, 0x4E, 0x01, 0x00, 0x00, 0x00, 0x48,
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35,
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D,
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+
+    struct cryptographic_parameters cp = {0};
+    kmip_init_cryptographic_parameters(&cp);
+    
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+
+    struct mac_signature_key_information expected = {0};
+    expected.unique_identifier = &uuid;
+    expected.cryptographic_parameters = &cp;
+    
+    struct mac_signature_key_information observed = {0};
+    
+    int result = kmip_decode_mac_signature_key_information(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_mac_signature_key_information(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_mac_signature_key_information(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_key_wrapping_data(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[104] = {
+        0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35,
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10,
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[104] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    struct key_wrapping_data kwd = {0};
+    kwd.wrapping_method = KMIP_WRAP_ENCRYPT;
+    kwd.encryption_key_info = &eki;
+    
+    int result = kmip_encode_key_wrapping_data(&ctx, &kwd);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_key_wrapping_data(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[104] = {
+        0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35,
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10,
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    kmip_init_cryptographic_parameters(&cp);
+    
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    struct key_wrapping_data expected = {0};
+    expected.wrapping_method = KMIP_WRAP_ENCRYPT;
+    expected.encryption_key_info = &eki;
+    
+    struct key_wrapping_data observed = {0};
+    
+    int result = kmip_decode_key_wrapping_data(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_key_wrapping_data(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_key_wrapping_data(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_key_material_byte_string(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[24] = {
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10,
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+    };
+    
+    uint8 observed[24] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    uint8 value[16] = {
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    int result = kmip_encode_key_material(&ctx, KMIP_KEYFORMAT_RAW, &key);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_key_material_byte_string(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[24] = {
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10,
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 value[16] = {
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+    };
+    struct byte_string expected = {0};
+    expected.value = value;
+    expected.size = ARRAY_LENGTH(value);
+    
+    struct byte_string *expected_ptr = &expected;
+    struct byte_string *observed_ptr = NULL;
+    
+    int result = kmip_decode_key_material(
+        &ctx,
+        KMIP_KEYFORMAT_RAW,
+        (void**)&observed_ptr);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_key_material(KMIP_KEYFORMAT_RAW, (void**)&expected_ptr, (void**)&observed_ptr),
+        result,
+        __func__);
+    kmip_free_key_material(&ctx, KMIP_KEYFORMAT_RAW, (void**)&observed_ptr);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_key_material_transparent_symmetric_key(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[48] = {
+        0x42, 0x00, 0x43, 0x01, 0x00, 0x00, 0x00, 0x28, 
+        0x42, 0x00, 0x3F, 0x08, 0x00, 0x00, 0x00, 0x20, 
+        0x00, 0x00, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33, 
+        0x44, 0x44, 0x55, 0x55, 0x66, 0x66, 0x77, 0x77,
+        0x88, 0x88, 0x99, 0x99, 0xAA, 0xAA, 0xBB, 0xBB,
+        0xCC, 0xCC, 0xDD, 0xDD, 0xEE, 0xEE, 0xFF, 0xFF
+    };
+    
+    uint8 observed[48] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    uint8 value[32] = {
+        0x00, 0x00, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33, 
+        0x44, 0x44, 0x55, 0x55, 0x66, 0x66, 0x77, 0x77,
+        0x88, 0x88, 0x99, 0x99, 0xAA, 0xAA, 0xBB, 0xBB,
+        0xCC, 0xCC, 0xDD, 0xDD, 0xEE, 0xEE, 0xFF, 0xFF
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    struct transparent_symmetric_key tsk = {0};
+    tsk.key = &key;
+    
+    int result = kmip_encode_key_material(&ctx, KMIP_KEYFORMAT_TRANS_SYMMETRIC_KEY, &tsk);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_key_material_transparent_symmetric_key(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[48] = {
+        0x42, 0x00, 0x43, 0x01, 0x00, 0x00, 0x00, 0x28, 
+        0x42, 0x00, 0x3F, 0x08, 0x00, 0x00, 0x00, 0x20, 
+        0x00, 0x00, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33, 
+        0x44, 0x44, 0x55, 0x55, 0x66, 0x66, 0x77, 0x77,
+        0x88, 0x88, 0x99, 0x99, 0xAA, 0xAA, 0xBB, 0xBB,
+        0xCC, 0xCC, 0xDD, 0xDD, 0xEE, 0xEE, 0xFF, 0xFF
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 value[32] = {
+        0x00, 0x00, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33, 
+        0x44, 0x44, 0x55, 0x55, 0x66, 0x66, 0x77, 0x77,
+        0x88, 0x88, 0x99, 0x99, 0xAA, 0xAA, 0xBB, 0xBB,
+        0xCC, 0xCC, 0xDD, 0xDD, 0xEE, 0xEE, 0xFF, 0xFF
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    struct transparent_symmetric_key expected = {0};
+    expected.key = &key;
+    
+    struct transparent_symmetric_key *expected_ptr = &expected;
+    struct transparent_symmetric_key *observed_ptr = NULL;
+    
+    int result = kmip_decode_key_material(
+        &ctx,
+        KMIP_KEYFORMAT_TRANS_SYMMETRIC_KEY,
+        (void**)&observed_ptr);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_key_material(KMIP_KEYFORMAT_TRANS_SYMMETRIC_KEY, (void**)&expected_ptr, (void**)&observed_ptr),
+        result,
+        __func__);
+    kmip_free_key_material(
+        &ctx,
+        KMIP_KEYFORMAT_TRANS_SYMMETRIC_KEY,
+        (void**)&observed_ptr);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_key_value(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[32] = {
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18,
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10,
+        0xD3, 0x51, 0x91, 0x0F, 0x1D, 0x79, 0x34, 0xD6,
+        0xE2, 0xAE, 0x17, 0x57, 0x65, 0x64, 0xE2, 0xBC
+    };
+    
+    uint8 observed[32] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    uint8 value[16] = {
+        0xD3, 0x51, 0x91, 0x0F, 0x1D, 0x79, 0x34, 0xD6,
+        0xE2, 0xAE, 0x17, 0x57, 0x65, 0x64, 0xE2, 0xBC
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &key;
+    
+    int result = kmip_encode_key_value(&ctx, KMIP_KEYFORMAT_RAW, &kv);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_key_value(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[32] = {
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18,
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10,
+        0xD3, 0x51, 0x91, 0x0F, 0x1D, 0x79, 0x34, 0xD6,
+        0xE2, 0xAE, 0x17, 0x57, 0x65, 0x64, 0xE2, 0xBC
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 value[16] = {
+        0xD3, 0x51, 0x91, 0x0F, 0x1D, 0x79, 0x34, 0xD6,
+        0xE2, 0xAE, 0x17, 0x57, 0x65, 0x64, 0xE2, 0xBC
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct key_value expected = {0};
+    expected.key_material = &key;
+    struct key_value observed = {0};
+    
+    int result = kmip_decode_key_value(&ctx, KMIP_KEYFORMAT_RAW, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_key_value(KMIP_KEYFORMAT_RAW, &expected, &observed),
+        result,
+        __func__);
+    kmip_free_key_value(&ctx, KMIP_KEYFORMAT_RAW, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_key_value_with_attributes(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[144] = {
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x88, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, 
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, 
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, 
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14,
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, 
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[144] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    uint8 value[16] = {
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct attribute attributes[2] = {0};
+    for(int i = 0; i < 2; i++)
+    {
+        kmip_init_attribute(&attributes[i]);
+    }
+    
+    enum cryptographic_algorithm ca = KMIP_CRYPTOALG_AES;
+    int length = 128;
+    attributes[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    attributes[0].value = &ca;
+    attributes[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    attributes[1].value = &length;
+    
+    struct key_value kv = {0};
+    kv.key_material = &key;
+    kv.attributes = attributes;
+    kv.attribute_count = ARRAY_LENGTH(attributes);
+    
+    int result = kmip_encode_key_value(&ctx, KMIP_KEYFORMAT_RAW, &kv);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_key_value_with_attributes(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[144] = {
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x88, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, 
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, 
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, 
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14,
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, 
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 value[16] = {
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct attribute attributes[2] = {0};
+    for(size_t i = 0; i < 2; i++)
+    {
+        kmip_init_attribute(&attributes[i]);
+    }
+    
+    enum cryptographic_algorithm ca = KMIP_CRYPTOALG_AES;
+    int length = 128;
+    attributes[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    attributes[0].value = &ca;
+    attributes[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    attributes[1].value = &length;
+    
+    struct key_value expected = {0};
+    expected.key_material = &key;
+    expected.attributes = attributes;
+    expected.attribute_count = ARRAY_LENGTH(attributes);
+    struct key_value observed = {0};
+    
+    int result = kmip_decode_key_value(&ctx, KMIP_KEYFORMAT_RAW, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_key_value(KMIP_KEYFORMAT_RAW, &expected, &observed),
+        result,
+        __func__);
+    kmip_free_key_value(&ctx, KMIP_KEYFORMAT_RAW, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_key_block_key_value_byte_string(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[192] = {
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0xB8, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x1F, 0xA6, 0x8B, 0x0A, 0x81, 0x12, 0xB4, 0x47, 
+        0xAE, 0xF3, 0x4B, 0xD8, 0xFB, 0x5A, 0x7B, 0x82, 
+        0x9D, 0x3E, 0x86, 0x23, 0x71, 0xD2, 0xCF, 0xE5, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, 
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[192] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    uint8 value[24] = {
+        0x1F, 0xA6, 0x8B, 0x0A, 0x81, 0x12, 0xB4, 0x47,
+        0xAE, 0xF3, 0x4B, 0xD8, 0xFB, 0x5A, 0x7B, 0x82,
+        0x9D, 0x3E, 0x86, 0x23, 0x71, 0xD2, 0xCF, 0xE5
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    struct key_wrapping_data kwd = {0};
+    kwd.wrapping_method = KMIP_WRAP_ENCRYPT;
+    kwd.encryption_key_info = &eki;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &key;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_AES;
+    kb.cryptographic_length = 128;
+    kb.key_wrapping_data = &kwd;
+    
+    int result = kmip_encode_key_block(&ctx, &kb);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_key_block_key_value_byte_string(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[192] = {
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0xB8, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x1F, 0xA6, 0x8B, 0x0A, 0x81, 0x12, 0xB4, 0x47, 
+        0xAE, 0xF3, 0x4B, 0xD8, 0xFB, 0x5A, 0x7B, 0x82, 
+        0x9D, 0x3E, 0x86, 0x23, 0x71, 0xD2, 0xCF, 0xE5, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, 
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 value[24] = {
+        0x1F, 0xA6, 0x8B, 0x0A, 0x81, 0x12, 0xB4, 0x47,
+        0xAE, 0xF3, 0x4B, 0xD8, 0xFB, 0x5A, 0x7B, 0x82,
+        0x9D, 0x3E, 0x86, 0x23, 0x71, 0xD2, 0xCF, 0xE5
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    kmip_init_cryptographic_parameters(&cp);
+    
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    struct key_wrapping_data kwd = {0};
+    kwd.wrapping_method = KMIP_WRAP_ENCRYPT;
+    kwd.encryption_key_info = &eki;
+    
+    struct key_block expected = {0};
+    kmip_init_key_block(&expected);
+    
+    expected.key_format_type = KMIP_KEYFORMAT_RAW;
+    expected.key_value = &key;
+    expected.key_value_type = KMIP_TYPE_BYTE_STRING;
+    expected.cryptographic_algorithm = KMIP_CRYPTOALG_AES;
+    expected.cryptographic_length = 128;
+    expected.key_wrapping_data = &kwd;
+    
+    struct key_block observed = {0};
+    kmip_init_key_block(&observed);
+    
+    int result = kmip_decode_key_block(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_key_block(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_key_block(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_key_block_key_value_structure(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[88] = {
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x50, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, 
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[88] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    uint8 value[16] = {
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &key;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &kv;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_AES;
+    kb.cryptographic_length = 128;
+    
+    int result = kmip_encode_key_block(&ctx, &kb);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_key_block_key_value_structure(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[88] = {
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x50, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, 
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 value[16] = {
+        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &key;
+    
+    struct key_block expected = {0};
+    kmip_init_key_block(&expected);
+    
+    expected.key_format_type = KMIP_KEYFORMAT_RAW;
+    expected.key_value = &kv;
+    expected.key_value_type = KMIP_TYPE_STRUCTURE;
+    expected.cryptographic_algorithm = KMIP_CRYPTOALG_AES;
+    expected.cryptographic_length = 128;
+    
+    struct key_block observed = {0};
+    kmip_init_key_block(&observed);
+    
+    int result = kmip_decode_key_block(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_key_block(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_key_block(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_symmetric_key(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[96] = {
+        0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x58, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x50, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, 
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+        0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[96] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    uint8 value[16] = {
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+        0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &key;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &kv;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_AES;
+    kb.cryptographic_length = 128;
+    
+    struct symmetric_key sk = {0};
+    sk.key_block = &kb;
+    
+    int result = kmip_encode_symmetric_key(&ctx, &sk);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_symmetric_key(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[96] = {
+        0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x58, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x50, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x18, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x10, 
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+        0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 value[16] = {
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+        0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &key;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &kv;
+    kb.key_value_type = KMIP_TYPE_STRUCTURE;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_AES;
+    kb.cryptographic_length = 128;
+    
+    struct symmetric_key expected = {0};
+    expected.key_block = &kb;
+    
+    struct symmetric_key observed = {0};
+    
+    int result = kmip_decode_symmetric_key(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_symmetric_key(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_symmetric_key(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_public_key(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[248] = {
+        0x42, 0x00, 0x6D, 0x01, 0x00, 0x00, 0x00, 0xF0, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0xE8, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0xB0, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0xA2,
+        0x30, 0x81, 0x9F, 0x30, 0x0D, 0x06, 0x09, 0x2A,
+        0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 
+        0x05, 0x00, 0x03, 0x81, 0x8D, 0x00, 0x30, 0x81, 
+        0x89, 0x02, 0x81, 0x81, 0x00, 0x93, 0x04, 0x51,
+        0xC9, 0xEC, 0xD9, 0x4F, 0x5B, 0xB9, 0xDA, 0x17, 
+        0xDD, 0x09, 0x38, 0x1B, 0xD2, 0x3B, 0xE4, 0x3E, 
+        0xCA, 0x8C, 0x75, 0x39, 0xF3, 0x01, 0xFC, 0x8A, 
+        0x8C, 0xD5, 0xD5, 0x27, 0x4C, 0x3E, 0x76, 0x99, 
+        0xDB, 0xDC, 0x71, 0x1C, 0x97, 0xA7, 0xAA, 0x91, 
+        0xE2, 0xC5, 0x0A, 0x82, 0xBD, 0x0B, 0x10, 0x34, 
+        0xF0, 0xDF, 0x49, 0x3D, 0xEC, 0x16, 0x36, 0x24,
+        0x27, 0xE5, 0x8A, 0xCC, 0xE7, 0xF6, 0xCE, 0x0F, 
+        0x9B, 0xCC, 0x61, 0x7B, 0xBD, 0x8C, 0x90, 0xD0, 
+        0x09, 0x4A, 0x27, 0x03, 0xBA, 0x0D, 0x09, 0xEB, 
+        0x19, 0xD1, 0x00, 0x5F, 0x2F, 0xB2, 0x65, 0x52, 
+        0x6A, 0xAC, 0x75, 0xAF, 0x32, 0xF8, 0xBC, 0x78, 
+        0x2C, 0xDE, 0xD2, 0xA5, 0x7F, 0x81, 0x1E, 0x03,
+        0xEA, 0xF6, 0x7A, 0x94, 0x4D, 0xE5, 0xE7, 0x84, 
+        0x13, 0xDC, 0xA8, 0xF2, 0x32, 0xD0, 0x74, 0xE6,
+        0xDC, 0xEA, 0x4C, 0xEC, 0x9F, 0x02, 0x03, 0x01, 
+        0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[248] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    uint8 value[162] = {
+        0x30, 0x81, 0x9F, 0x30, 0x0D, 0x06, 0x09, 0x2A, 
+        0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 
+        0x05, 0x00, 0x03, 0x81, 0x8D, 0x00, 0x30, 0x81, 
+        0x89, 0x02, 0x81, 0x81, 0x00, 0x93, 0x04, 0x51,
+        0xC9, 0xEC, 0xD9, 0x4F, 0x5B, 0xB9, 0xDA, 0x17, 
+        0xDD, 0x09, 0x38, 0x1B, 0xD2, 0x3B, 0xE4, 0x3E, 
+        0xCA, 0x8C, 0x75, 0x39, 0xF3, 0x01, 0xFC, 0x8A, 
+        0x8C, 0xD5, 0xD5, 0x27, 0x4C, 0x3E, 0x76, 0x99,
+        0xDB, 0xDC, 0x71, 0x1C, 0x97, 0xA7, 0xAA, 0x91, 
+        0xE2, 0xC5, 0x0A, 0x82, 0xBD, 0x0B, 0x10, 0x34, 
+        0xF0, 0xDF, 0x49, 0x3D, 0xEC, 0x16, 0x36, 0x24, 
+        0x27, 0xE5, 0x8A, 0xCC, 0xE7, 0xF6, 0xCE, 0x0F, 
+        0x9B, 0xCC, 0x61, 0x7B, 0xBD, 0x8C, 0x90, 0xD0, 
+        0x09, 0x4A, 0x27, 0x03, 0xBA, 0x0D, 0x09, 0xEB, 
+        0x19, 0xD1, 0x00, 0x5F, 0x2F, 0xB2, 0x65, 0x52, 
+        0x6A, 0xAC, 0x75, 0xAF, 0x32, 0xF8, 0xBC, 0x78, 
+        0x2C, 0xDE, 0xD2, 0xA5, 0x7F, 0x81, 0x1E, 0x03, 
+        0xEA, 0xF6, 0x7A, 0x94, 0x4D, 0xE5, 0xE7, 0x84,
+        0x13, 0xDC, 0xA8, 0xF2, 0x32, 0xD0, 0x74, 0xE6,
+        0xDC, 0xEA, 0x4C, 0xEC, 0x9F, 0x02, 0x03, 0x01,
+        0x00, 0x01
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &key;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_X509;
+    kb.key_value = &kv;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_RSA;
+    kb.cryptographic_length = 1024;
+    
+    struct public_key pk = {0};
+    pk.key_block = &kb;
+    
+    int result = kmip_encode_public_key(&ctx, &pk);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_public_key(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[248] = {
+        0x42, 0x00, 0x6D, 0x01, 0x00, 0x00, 0x00, 0xF0, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0xE8, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0xB0, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0xA2,
+        0x30, 0x81, 0x9F, 0x30, 0x0D, 0x06, 0x09, 0x2A,
+        0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 
+        0x05, 0x00, 0x03, 0x81, 0x8D, 0x00, 0x30, 0x81, 
+        0x89, 0x02, 0x81, 0x81, 0x00, 0x93, 0x04, 0x51,
+        0xC9, 0xEC, 0xD9, 0x4F, 0x5B, 0xB9, 0xDA, 0x17, 
+        0xDD, 0x09, 0x38, 0x1B, 0xD2, 0x3B, 0xE4, 0x3E, 
+        0xCA, 0x8C, 0x75, 0x39, 0xF3, 0x01, 0xFC, 0x8A, 
+        0x8C, 0xD5, 0xD5, 0x27, 0x4C, 0x3E, 0x76, 0x99, 
+        0xDB, 0xDC, 0x71, 0x1C, 0x97, 0xA7, 0xAA, 0x91, 
+        0xE2, 0xC5, 0x0A, 0x82, 0xBD, 0x0B, 0x10, 0x34, 
+        0xF0, 0xDF, 0x49, 0x3D, 0xEC, 0x16, 0x36, 0x24,
+        0x27, 0xE5, 0x8A, 0xCC, 0xE7, 0xF6, 0xCE, 0x0F, 
+        0x9B, 0xCC, 0x61, 0x7B, 0xBD, 0x8C, 0x90, 0xD0, 
+        0x09, 0x4A, 0x27, 0x03, 0xBA, 0x0D, 0x09, 0xEB, 
+        0x19, 0xD1, 0x00, 0x5F, 0x2F, 0xB2, 0x65, 0x52, 
+        0x6A, 0xAC, 0x75, 0xAF, 0x32, 0xF8, 0xBC, 0x78, 
+        0x2C, 0xDE, 0xD2, 0xA5, 0x7F, 0x81, 0x1E, 0x03,
+        0xEA, 0xF6, 0x7A, 0x94, 0x4D, 0xE5, 0xE7, 0x84, 
+        0x13, 0xDC, 0xA8, 0xF2, 0x32, 0xD0, 0x74, 0xE6,
+        0xDC, 0xEA, 0x4C, 0xEC, 0x9F, 0x02, 0x03, 0x01, 
+        0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 value[162] = {
+        0x30, 0x81, 0x9F, 0x30, 0x0D, 0x06, 0x09, 0x2A, 
+        0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 
+        0x05, 0x00, 0x03, 0x81, 0x8D, 0x00, 0x30, 0x81, 
+        0x89, 0x02, 0x81, 0x81, 0x00, 0x93, 0x04, 0x51,
+        0xC9, 0xEC, 0xD9, 0x4F, 0x5B, 0xB9, 0xDA, 0x17, 
+        0xDD, 0x09, 0x38, 0x1B, 0xD2, 0x3B, 0xE4, 0x3E, 
+        0xCA, 0x8C, 0x75, 0x39, 0xF3, 0x01, 0xFC, 0x8A, 
+        0x8C, 0xD5, 0xD5, 0x27, 0x4C, 0x3E, 0x76, 0x99,
+        0xDB, 0xDC, 0x71, 0x1C, 0x97, 0xA7, 0xAA, 0x91, 
+        0xE2, 0xC5, 0x0A, 0x82, 0xBD, 0x0B, 0x10, 0x34, 
+        0xF0, 0xDF, 0x49, 0x3D, 0xEC, 0x16, 0x36, 0x24, 
+        0x27, 0xE5, 0x8A, 0xCC, 0xE7, 0xF6, 0xCE, 0x0F, 
+        0x9B, 0xCC, 0x61, 0x7B, 0xBD, 0x8C, 0x90, 0xD0, 
+        0x09, 0x4A, 0x27, 0x03, 0xBA, 0x0D, 0x09, 0xEB, 
+        0x19, 0xD1, 0x00, 0x5F, 0x2F, 0xB2, 0x65, 0x52, 
+        0x6A, 0xAC, 0x75, 0xAF, 0x32, 0xF8, 0xBC, 0x78, 
+        0x2C, 0xDE, 0xD2, 0xA5, 0x7F, 0x81, 0x1E, 0x03, 
+        0xEA, 0xF6, 0x7A, 0x94, 0x4D, 0xE5, 0xE7, 0x84,
+        0x13, 0xDC, 0xA8, 0xF2, 0x32, 0xD0, 0x74, 0xE6,
+        0xDC, 0xEA, 0x4C, 0xEC, 0x9F, 0x02, 0x03, 0x01,
+        0x00, 0x01
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &key;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_X509;
+    kb.key_value = &kv;
+    kb.key_value_type = KMIP_TYPE_STRUCTURE;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_RSA;
+    kb.cryptographic_length = 1024;
+    
+    struct public_key expected = {0};
+    expected.key_block = &kb;
+    
+    struct public_key observed = {0};
+    
+    int result = kmip_decode_public_key(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_public_key(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_public_key(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_private_key(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[1280] = {
+        0x42, 0x00, 0x64, 0x01, 0x00, 0x00, 0x04, 0xF8, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x04, 0xF0, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x04, 0xB8, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x04, 0xA9,
+        0x30, 0x82, 0x04, 0xA5, 0x02, 0x01, 0x00, 0x02, 
+        0x82, 0x01, 0x01, 0x00, 0xAB, 0x7F, 0x16, 0x1C, 
+        0x00, 0x42, 0x49, 0x6C, 0xCD, 0x6C, 0x6D, 0x4D, 
+        0xAD, 0xB9, 0x19, 0x97, 0x34, 0x35, 0x35, 0x77, 
+        0x76, 0x00, 0x3A, 0xCF, 0x54, 0xB7, 0xAF, 0x1E, 
+        0x44, 0x0A, 0xFB, 0x80, 0xB6, 0x4A, 0x87, 0x55, 
+        0xF8, 0x00, 0x2C, 0xFE, 0xBA, 0x6B, 0x18, 0x45, 
+        0x40, 0xA2, 0xD6, 0x60, 0x86, 0xD7, 0x46, 0x48, 
+        0x34, 0x6D, 0x75, 0xB8, 0xD7, 0x18, 0x12, 0xB2, 
+        0x05, 0x38, 0x7C, 0x0F, 0x65, 0x83, 0xBC, 0x4D, 
+        0x7D, 0xC7, 0xEC, 0x11, 0x4F, 0x3B, 0x17, 0x6B, 
+        0x79, 0x57, 0xC4, 0x22, 0xE7, 0xD0, 0x3F, 0xC6,
+        0x26, 0x7F, 0xA2, 0xA6, 0xF8, 0x9B, 0x9B, 0xEE, 
+        0x9E, 0x60, 0xA1, 0xD7, 0xC2, 0xD8, 0x33, 0xE5, 
+        0xA5, 0xF4, 0xBB, 0x0B, 0x14, 0x34, 0xF4, 0xE7, 
+        0x95, 0xA4, 0x11, 0x00, 0xF8, 0xAA, 0x21, 0x49, 
+        0x00, 0xDF, 0x8B, 0x65, 0x08, 0x9F, 0x98, 0x13, 
+        0x5B, 0x1C, 0x67, 0xB7, 0x01, 0x67, 0x5A, 0xBD, 
+        0xBC, 0x7D, 0x57, 0x21, 0xAA, 0xC9, 0xD1, 0x4A, 
+        0x7F, 0x08, 0x1F, 0xCE, 0xC8, 0x0B, 0x64, 0xE8, 
+        0xA0, 0xEC, 0xC8, 0x29, 0x53, 0x53, 0xC7, 0x95, 
+        0x32, 0x8A, 0xBF, 0x70, 0xE1, 0xB4, 0x2E, 0x7B, 
+        0xB8, 0xB7, 0xF4, 0xE8, 0xAC, 0x8C, 0x81, 0x0C, 
+        0xDB, 0x66, 0xE3, 0xD2, 0x11, 0x26, 0xEB, 0xA8, 
+        0xDA, 0x7D, 0x0C, 0xA3, 0x41, 0x42, 0xCB, 0x76, 
+        0xF9, 0x1F, 0x01, 0x3D, 0xA8, 0x09, 0xE9, 0xC1, 
+        0xB7, 0xAE, 0x64, 0xC5, 0x41, 0x30, 0xFB, 0xC2, 
+        0x1D, 0x80, 0xE9, 0xC2, 0xCB, 0x06, 0xC5, 0xC8, 
+        0xD7, 0xCC, 0xE8, 0x94, 0x6A, 0x9A, 0xC9, 0x9B,
+        0x1C, 0x28, 0x15, 0xC3, 0x61, 0x2A, 0x29, 0xA8, 
+        0x2D, 0x73, 0xA1, 0xF9, 0x93, 0x74, 0xFE, 0x30, 
+        0xE5, 0x49, 0x51, 0x66, 0x2A, 0x6E, 0xDA, 0x29, 
+        0xC6, 0xFC, 0x41, 0x13, 0x35, 0xD5, 0xDC, 0x74, 
+        0x26, 0xB0, 0xF6, 0x05, 0x02, 0x03, 0x01, 0x00, 
+        0x01, 0x02, 0x82, 0x01, 0x00, 0x3B, 0x12, 0x45, 
+        0x5D, 0x53, 0xC1, 0x81, 0x65, 0x16, 0xC5, 0x18, 
+        0x49, 0x3F, 0x63, 0x98, 0xAA, 0xFA, 0x72, 0xB1, 
+        0x7D, 0xFA, 0x89, 0x4D, 0xB8, 0x88, 0xA7, 0xD4, 
+        0x8C, 0x0A, 0x47, 0xF6, 0x25, 0x79, 0xA4, 0xE6, 
+        0x44, 0xF8, 0x6D, 0xA7, 0x11, 0xFE, 0xC8, 0x50, 
+        0xCD, 0xD9, 0xDB, 0xBD, 0x17, 0xF6, 0x9A, 0x44, 
+        0x3D, 0x2E, 0xC1, 0xDD, 0x60, 0xD3, 0xC6, 0x18, 
+        0xFA, 0x74, 0xCD, 0xE5, 0xFD, 0xAF, 0xAB, 0xD6, 
+        0xBA, 0xA2, 0x6E, 0xB0, 0xA3, 0xAD, 0xB4, 0xDE, 
+        0xF6, 0x48, 0x0F, 0xB1, 0x21, 0x8C, 0xD3, 0xB0,
+        0x83, 0xE2, 0x52, 0xE8, 0x85, 0xB6, 0xF0, 0x72, 
+        0x9F, 0x98, 0xB2, 0x14, 0x4D, 0x2B, 0x72, 0x29, 
+        0x3E, 0x1B, 0x11, 0xD7, 0x33, 0x93, 0xBC, 0x41, 
+        0xF7, 0x5B, 0x15, 0xEE, 0x3D, 0x75, 0x69, 0xB4, 
+        0x99, 0x5E, 0xD1, 0xA1, 0x44, 0x25, 0xDA, 0x43, 
+        0x19, 0xB7, 0xB2, 0x6B, 0x0E, 0x8F, 0xEF, 0x17, 
+        0xC3, 0x75, 0x42, 0xAE, 0x5C, 0x6D, 0x58, 0x49, 
+        0xF8, 0x72, 0x09, 0x56, 0x7F, 0x39, 0x25, 0xA4, 
+        0x7B, 0x01, 0x6D, 0x56, 0x48, 0x59, 0x71, 0x7B, 
+        0xC5, 0x7F, 0xCB, 0x45, 0x22, 0xD0, 0xAA, 0x49, 
+        0xCE, 0x81, 0x6E, 0x5B, 0xE7, 0xB3, 0x08, 0x81, 
+        0x93, 0x23, 0x6E, 0xC9, 0xEF, 0xFF, 0x14, 0x08, 
+        0x58, 0x04, 0x5B, 0x73, 0xC5, 0xD7, 0x9B, 0xAF, 
+        0x38, 0xF7, 0xC6, 0x7F, 0x04, 0xC5, 0xDC, 0xF0, 
+        0xE3, 0x80, 0x6A, 0xD9, 0x82, 0xD1, 0x25, 0x90, 
+        0x58, 0xC3, 0x47, 0x3E, 0x84, 0x71, 0x79, 0xA8, 
+        0x78, 0xF2, 0xC6, 0xB3, 0xBD, 0x96, 0x8F, 0xB9,
+        0x9E, 0xA4, 0x6E, 0x91, 0x85, 0x89, 0x2F, 0x36,
+        0x76, 0xE7, 0x89, 0x65, 0xC2, 0xAE, 0xD4, 0x87,
+        0x7B, 0xA3, 0x91, 0x7D, 0xF0, 0x7C, 0x5E, 0x92, 
+        0x74, 0x74, 0xF1, 0x9E, 0x76, 0x4B, 0xA6, 0x1D, 
+        0xC3, 0x8D, 0x63, 0xBF, 0x29, 0x02, 0x81, 0x81, 
+        0x00, 0xD5, 0xC6, 0x9C, 0x8C, 0x3C, 0xDC, 0x24, 
+        0x64, 0x74, 0x4A, 0x79, 0x37, 0x13, 0xDA, 0xFB, 
+        0x9F, 0x1D, 0xBC, 0x79, 0x9F, 0xF9, 0x64, 0x23, 
+        0xFE, 0xCD, 0x3C, 0xBA, 0x79, 0x42, 0x86, 0xBC, 
+        0xE9, 0x20, 0xF4, 0xB5, 0xC1, 0x83, 0xF9, 0x9E, 
+        0xE9, 0x02, 0x8D, 0xB6, 0x21, 0x2C, 0x62, 0x77, 
+        0xC4, 0xC8, 0x29, 0x7F, 0xCF, 0xBC, 0xE7, 0xF7,
+        0xC2, 0x4C, 0xA4, 0xC5, 0x1F, 0xC7, 0x18, 0x2F, 
+        0xB8, 0xF4, 0x01, 0x9F, 0xB1, 0xD5, 0x65, 0x96, 
+        0x74, 0xC5, 0xCB, 0xE6, 0xD5, 0xFA, 0x99, 0x20, 
+        0x51, 0x34, 0x17, 0x60, 0xCD, 0x00, 0x73, 0x57, 
+        0x29, 0xA0, 0x70, 0xA9, 0xE5, 0x4D, 0x34, 0x2B, 
+        0xEB, 0xA8, 0xEF, 0x47, 0xEE, 0x82, 0xD3, 0xA0, 
+        0x1B, 0x04, 0xCE, 0xC4, 0xA0, 0x0D, 0x4D, 0xDB,
+        0x41, 0xE3, 0x51, 0x16, 0xFC, 0x22, 0x1E, 0x85, 
+        0x4B, 0x43, 0xA6, 0x96, 0xC0, 0xE6, 0x41, 0x9B, 
+        0x1B, 0x02, 0x81, 0x81, 0x00, 0xCD, 0x5E, 0xA7, 
+        0x70, 0x27, 0x89, 0x06, 0x4B, 0x67, 0x35, 0x40, 
+        0xCB, 0xFF, 0x09, 0x35, 0x6A, 0xD8, 0x0B, 0xC3, 
+        0xD5, 0x92, 0x81, 0x2E, 0xBA, 0x47, 0x61, 0x0B,
+        0x9F, 0xAC, 0x6A, 0xEC, 0xEF, 0xE2, 0x2A, 0xCA, 
+        0xE4, 0x38, 0x45, 0x9C, 0xDA, 0x74, 0xE5, 0x96, 
+        0x53, 0xD8, 0x8C, 0x04, 0x18, 0x9D, 0x34, 0x39, 
+        0x9B, 0xF5, 0xB1, 0x4B, 0x92, 0x0E, 0x34, 0xEF, 
+        0x38, 0xA7, 0xD0, 0x9F, 0xE6, 0x95, 0x93, 0x39, 
+        0x6E, 0x8F, 0xE7, 0x35, 0xE6, 0xF0, 0xA6, 0xAE, 
+        0x49, 0x90, 0x40, 0x10, 0x41, 0xD8, 0xA4, 0x06, 
+        0xB6, 0xFD, 0x86, 0xA1, 0x16, 0x1E, 0x45, 0xF9,
+        0x5A, 0x3E, 0xAA, 0x5C, 0x10, 0x12, 0xE6, 0x66,
+        0x2E, 0x44, 0xF1, 0x5F, 0x33, 0x5A, 0xC9, 0x71, 
+        0xE1, 0x76, 0x6B, 0x2B, 0xB9, 0xC9, 0x85, 0x10, 
+        0x99, 0x74, 0x14, 0x1B, 0x44, 0xD3, 0x7E, 0x1E, 
+        0x31, 0x98, 0x20, 0xA5, 0x5F, 0x02, 0x81, 0x81, 
+        0x00, 0xB2, 0x87, 0x12, 0x37, 0xBF, 0x9F, 0xAD, 
+        0x38, 0xC3, 0x31, 0x6A, 0xB7, 0x87, 0x7A, 0x6A, 
+        0x86, 0x80, 0x63, 0xE5, 0x42, 0xA7, 0x18, 0x6D, 
+        0x43, 0x1E, 0x8D, 0x27, 0xC1, 0x9A, 0xC0, 0x41, 
+        0x45, 0x84, 0x03, 0x39, 0x42, 0xE9, 0xFF, 0x6E, 
+        0x29, 0x73, 0xBB, 0x7B, 0x2D, 0x8B, 0x0E, 0x94, 
+        0xAD, 0x1E, 0xE8, 0x21, 0x58, 0x10, 0x8F, 0xBC,
+        0x86, 0x64, 0x51, 0x7A, 0x5A, 0x46, 0x7F, 0xB9, 
+        0x63, 0x01, 0x4B, 0xD5, 0xDC, 0xC2, 0xB4, 0xFB, 
+        0x08, 0x7C, 0x23, 0x03, 0x9D, 0x11, 0x92, 0x0D, 
+        0xBE, 0x22, 0xFD, 0x9F, 0x16, 0xB4, 0xD8, 0x9E, 
+        0x23, 0x22, 0x5C, 0xD4, 0x55, 0xAD, 0xBA, 0xF3, 
+        0x2E, 0xF4, 0x3F, 0x18, 0x58, 0x64, 0xA3, 0x6D,
+        0x63, 0x03, 0x09, 0xD6, 0x85, 0x3F, 0x77, 0x14,
+        0xB3, 0x9A, 0xAE, 0x1E, 0xBE, 0xE3, 0x93, 0x8F, 
+        0x87, 0xC2, 0x70, 0x7E, 0x17, 0x8C, 0x73, 0x9F, 
+        0x9F, 0x02, 0x81, 0x81, 0x00, 0x96, 0x90, 0xBE,
+        0xD1, 0x4B, 0x2A, 0xFA, 0xA2, 0x6D, 0x98, 0x6D, 
+        0x59, 0x22, 0x31, 0xEE, 0x27, 0xD7, 0x1D, 0x49, 
+        0x06, 0x5B, 0xD2, 0xBA, 0x1F, 0x78, 0x15, 0x7E, 
+        0x20, 0x22, 0x98, 0x81, 0xFD, 0x9D, 0x23, 0x22, 
+        0x7D, 0x0F, 0x84, 0x79, 0xEA, 0xEF, 0xA9, 0x22, 
+        0xFD, 0x75, 0xD5, 0xB1, 0x6B, 0x1A, 0x56, 0x1F,
+        0xA6, 0x68, 0x0B, 0x04, 0x0C, 0xA0, 0xBD, 0xCE, 
+        0x65, 0x0B, 0x23, 0xB9, 0x17, 0xA4, 0xB1, 0xBB, 
+        0x79, 0x83, 0xA7, 0x4F, 0xAD, 0x70, 0xE1, 0xC3, 
+        0x05, 0xCB, 0xEC, 0x2B, 0xFF, 0x1A, 0x85, 0xA7,
+        0x26, 0xA1, 0xD9, 0x02, 0x60, 0xE4, 0xF1, 0x08, 
+        0x4F, 0x51, 0x82, 0x34, 0xDC, 0xD3, 0xFE, 0x77, 
+        0x0B, 0x95, 0x20, 0x21, 0x5B, 0xD5, 0x43, 0xBB, 
+        0x6A, 0x41, 0x17, 0x71, 0x87, 0x54, 0x67, 0x6A, 
+        0x34, 0x17, 0x16, 0x66, 0xA7, 0x9F, 0x26, 0xE7, 
+        0x9C, 0x14, 0x9C, 0x5A, 0xA1, 0x02, 0x81, 0x81, 
+        0x00, 0xA0, 0xC9, 0x85, 0xA0, 0xA0, 0xA7, 0x91, 
+        0xA6, 0x59, 0xF9, 0x97, 0x31, 0x13, 0x4C, 0x44, 
+        0xF3, 0x7B, 0x2E, 0x52, 0x0A, 0x2C, 0xEA, 0x35, 
+        0x80, 0x0A, 0xD2, 0x72, 0x41, 0xED, 0x36, 0x0D, 
+        0xFD, 0xE6, 0xE8, 0xCA, 0x61, 0x4F, 0x12, 0x04, 
+        0x7F, 0xD0, 0x8B, 0x76, 0xAC, 0x4D, 0x13, 0xC0, 
+        0x56, 0xA0, 0x69, 0x9E, 0x2F, 0x98, 0xA1, 0xCA, 
+        0xC9, 0x10, 0x11, 0x29, 0x4D, 0x71, 0x20, 0x8F, 
+        0x4A, 0xBA, 0xB3, 0x3B, 0xA8, 0x7A, 0xA0, 0x51, 
+        0x7F, 0x41, 0x5B, 0xAC, 0xA8, 0x8D, 0x6B, 0xAC, 
+        0x00, 0x60, 0x88, 0xFA, 0x60, 0x1D, 0x34, 0x94, 
+        0x17, 0xE1, 0xF0, 0xC9, 0xB2, 0x3A, 0xFF, 0xA4, 
+        0xD4, 0x96, 0x61, 0x8D, 0xBC, 0x02, 0x49, 0x86, 
+        0xED, 0x69, 0x0B, 0xBB, 0x7B, 0x02, 0x57, 0x68, 
+        0xFF, 0x9D, 0xF8, 0xAC, 0x15, 0x41, 0x6F, 0x48, 
+        0x9F, 0x81, 0x29, 0xC3, 0x23, 0x41, 0xA8, 0xB4, 
+        0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[1280] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    uint8 value[1193] = {
+        0x30, 0x82, 0x04, 0xA5, 0x02, 0x01, 0x00, 0x02, 
+        0x82, 0x01, 0x01, 0x00, 0xAB, 0x7F, 0x16, 0x1C, 
+        0x00, 0x42, 0x49, 0x6C, 0xCD, 0x6C, 0x6D, 0x4D, 
+        0xAD, 0xB9, 0x19, 0x97, 0x34, 0x35, 0x35, 0x77, 
+        0x76, 0x00, 0x3A, 0xCF, 0x54, 0xB7, 0xAF, 0x1E, 
+        0x44, 0x0A, 0xFB, 0x80, 0xB6, 0x4A, 0x87, 0x55, 
+        0xF8, 0x00, 0x2C, 0xFE, 0xBA, 0x6B, 0x18, 0x45, 
+        0x40, 0xA2, 0xD6, 0x60, 0x86, 0xD7, 0x46, 0x48, 
+        0x34, 0x6D, 0x75, 0xB8, 0xD7, 0x18, 0x12, 0xB2, 
+        0x05, 0x38, 0x7C, 0x0F, 0x65, 0x83, 0xBC, 0x4D, 
+        0x7D, 0xC7, 0xEC, 0x11, 0x4F, 0x3B, 0x17, 0x6B, 
+        0x79, 0x57, 0xC4, 0x22, 0xE7, 0xD0, 0x3F, 0xC6,
+        0x26, 0x7F, 0xA2, 0xA6, 0xF8, 0x9B, 0x9B, 0xEE, 
+        0x9E, 0x60, 0xA1, 0xD7, 0xC2, 0xD8, 0x33, 0xE5, 
+        0xA5, 0xF4, 0xBB, 0x0B, 0x14, 0x34, 0xF4, 0xE7, 
+        0x95, 0xA4, 0x11, 0x00, 0xF8, 0xAA, 0x21, 0x49, 
+        0x00, 0xDF, 0x8B, 0x65, 0x08, 0x9F, 0x98, 0x13, 
+        0x5B, 0x1C, 0x67, 0xB7, 0x01, 0x67, 0x5A, 0xBD, 
+        0xBC, 0x7D, 0x57, 0x21, 0xAA, 0xC9, 0xD1, 0x4A, 
+        0x7F, 0x08, 0x1F, 0xCE, 0xC8, 0x0B, 0x64, 0xE8, 
+        0xA0, 0xEC, 0xC8, 0x29, 0x53, 0x53, 0xC7, 0x95, 
+        0x32, 0x8A, 0xBF, 0x70, 0xE1, 0xB4, 0x2E, 0x7B, 
+        0xB8, 0xB7, 0xF4, 0xE8, 0xAC, 0x8C, 0x81, 0x0C, 
+        0xDB, 0x66, 0xE3, 0xD2, 0x11, 0x26, 0xEB, 0xA8, 
+        0xDA, 0x7D, 0x0C, 0xA3, 0x41, 0x42, 0xCB, 0x76, 
+        0xF9, 0x1F, 0x01, 0x3D, 0xA8, 0x09, 0xE9, 0xC1, 
+        0xB7, 0xAE, 0x64, 0xC5, 0x41, 0x30, 0xFB, 0xC2, 
+        0x1D, 0x80, 0xE9, 0xC2, 0xCB, 0x06, 0xC5, 0xC8, 
+        0xD7, 0xCC, 0xE8, 0x94, 0x6A, 0x9A, 0xC9, 0x9B,
+        0x1C, 0x28, 0x15, 0xC3, 0x61, 0x2A, 0x29, 0xA8, 
+        0x2D, 0x73, 0xA1, 0xF9, 0x93, 0x74, 0xFE, 0x30, 
+        0xE5, 0x49, 0x51, 0x66, 0x2A, 0x6E, 0xDA, 0x29, 
+        0xC6, 0xFC, 0x41, 0x13, 0x35, 0xD5, 0xDC, 0x74, 
+        0x26, 0xB0, 0xF6, 0x05, 0x02, 0x03, 0x01, 0x00, 
+        0x01, 0x02, 0x82, 0x01, 0x00, 0x3B, 0x12, 0x45, 
+        0x5D, 0x53, 0xC1, 0x81, 0x65, 0x16, 0xC5, 0x18, 
+        0x49, 0x3F, 0x63, 0x98, 0xAA, 0xFA, 0x72, 0xB1, 
+        0x7D, 0xFA, 0x89, 0x4D, 0xB8, 0x88, 0xA7, 0xD4, 
+        0x8C, 0x0A, 0x47, 0xF6, 0x25, 0x79, 0xA4, 0xE6, 
+        0x44, 0xF8, 0x6D, 0xA7, 0x11, 0xFE, 0xC8, 0x50, 
+        0xCD, 0xD9, 0xDB, 0xBD, 0x17, 0xF6, 0x9A, 0x44, 
+        0x3D, 0x2E, 0xC1, 0xDD, 0x60, 0xD3, 0xC6, 0x18, 
+        0xFA, 0x74, 0xCD, 0xE5, 0xFD, 0xAF, 0xAB, 0xD6, 
+        0xBA, 0xA2, 0x6E, 0xB0, 0xA3, 0xAD, 0xB4, 0xDE, 
+        0xF6, 0x48, 0x0F, 0xB1, 0x21, 0x8C, 0xD3, 0xB0,
+        0x83, 0xE2, 0x52, 0xE8, 0x85, 0xB6, 0xF0, 0x72, 
+        0x9F, 0x98, 0xB2, 0x14, 0x4D, 0x2B, 0x72, 0x29, 
+        0x3E, 0x1B, 0x11, 0xD7, 0x33, 0x93, 0xBC, 0x41, 
+        0xF7, 0x5B, 0x15, 0xEE, 0x3D, 0x75, 0x69, 0xB4, 
+        0x99, 0x5E, 0xD1, 0xA1, 0x44, 0x25, 0xDA, 0x43, 
+        0x19, 0xB7, 0xB2, 0x6B, 0x0E, 0x8F, 0xEF, 0x17, 
+        0xC3, 0x75, 0x42, 0xAE, 0x5C, 0x6D, 0x58, 0x49, 
+        0xF8, 0x72, 0x09, 0x56, 0x7F, 0x39, 0x25, 0xA4, 
+        0x7B, 0x01, 0x6D, 0x56, 0x48, 0x59, 0x71, 0x7B, 
+        0xC5, 0x7F, 0xCB, 0x45, 0x22, 0xD0, 0xAA, 0x49, 
+        0xCE, 0x81, 0x6E, 0x5B, 0xE7, 0xB3, 0x08, 0x81, 
+        0x93, 0x23, 0x6E, 0xC9, 0xEF, 0xFF, 0x14, 0x08, 
+        0x58, 0x04, 0x5B, 0x73, 0xC5, 0xD7, 0x9B, 0xAF, 
+        0x38, 0xF7, 0xC6, 0x7F, 0x04, 0xC5, 0xDC, 0xF0, 
+        0xE3, 0x80, 0x6A, 0xD9, 0x82, 0xD1, 0x25, 0x90, 
+        0x58, 0xC3, 0x47, 0x3E, 0x84, 0x71, 0x79, 0xA8, 
+        0x78, 0xF2, 0xC6, 0xB3, 0xBD, 0x96, 0x8F, 0xB9,
+        0x9E, 0xA4, 0x6E, 0x91, 0x85, 0x89, 0x2F, 0x36,
+        0x76, 0xE7, 0x89, 0x65, 0xC2, 0xAE, 0xD4, 0x87,
+        0x7B, 0xA3, 0x91, 0x7D, 0xF0, 0x7C, 0x5E, 0x92, 
+        0x74, 0x74, 0xF1, 0x9E, 0x76, 0x4B, 0xA6, 0x1D, 
+        0xC3, 0x8D, 0x63, 0xBF, 0x29, 0x02, 0x81, 0x81, 
+        0x00, 0xD5, 0xC6, 0x9C, 0x8C, 0x3C, 0xDC, 0x24, 
+        0x64, 0x74, 0x4A, 0x79, 0x37, 0x13, 0xDA, 0xFB, 
+        0x9F, 0x1D, 0xBC, 0x79, 0x9F, 0xF9, 0x64, 0x23, 
+        0xFE, 0xCD, 0x3C, 0xBA, 0x79, 0x42, 0x86, 0xBC, 
+        0xE9, 0x20, 0xF4, 0xB5, 0xC1, 0x83, 0xF9, 0x9E, 
+        0xE9, 0x02, 0x8D, 0xB6, 0x21, 0x2C, 0x62, 0x77, 
+        0xC4, 0xC8, 0x29, 0x7F, 0xCF, 0xBC, 0xE7, 0xF7,
+        0xC2, 0x4C, 0xA4, 0xC5, 0x1F, 0xC7, 0x18, 0x2F, 
+        0xB8, 0xF4, 0x01, 0x9F, 0xB1, 0xD5, 0x65, 0x96, 
+        0x74, 0xC5, 0xCB, 0xE6, 0xD5, 0xFA, 0x99, 0x20, 
+        0x51, 0x34, 0x17, 0x60, 0xCD, 0x00, 0x73, 0x57, 
+        0x29, 0xA0, 0x70, 0xA9, 0xE5, 0x4D, 0x34, 0x2B, 
+        0xEB, 0xA8, 0xEF, 0x47, 0xEE, 0x82, 0xD3, 0xA0, 
+        0x1B, 0x04, 0xCE, 0xC4, 0xA0, 0x0D, 0x4D, 0xDB,
+        0x41, 0xE3, 0x51, 0x16, 0xFC, 0x22, 0x1E, 0x85, 
+        0x4B, 0x43, 0xA6, 0x96, 0xC0, 0xE6, 0x41, 0x9B, 
+        0x1B, 0x02, 0x81, 0x81, 0x00, 0xCD, 0x5E, 0xA7, 
+        0x70, 0x27, 0x89, 0x06, 0x4B, 0x67, 0x35, 0x40, 
+        0xCB, 0xFF, 0x09, 0x35, 0x6A, 0xD8, 0x0B, 0xC3, 
+        0xD5, 0x92, 0x81, 0x2E, 0xBA, 0x47, 0x61, 0x0B,
+        0x9F, 0xAC, 0x6A, 0xEC, 0xEF, 0xE2, 0x2A, 0xCA, 
+        0xE4, 0x38, 0x45, 0x9C, 0xDA, 0x74, 0xE5, 0x96, 
+        0x53, 0xD8, 0x8C, 0x04, 0x18, 0x9D, 0x34, 0x39, 
+        0x9B, 0xF5, 0xB1, 0x4B, 0x92, 0x0E, 0x34, 0xEF, 
+        0x38, 0xA7, 0xD0, 0x9F, 0xE6, 0x95, 0x93, 0x39, 
+        0x6E, 0x8F, 0xE7, 0x35, 0xE6, 0xF0, 0xA6, 0xAE, 
+        0x49, 0x90, 0x40, 0x10, 0x41, 0xD8, 0xA4, 0x06, 
+        0xB6, 0xFD, 0x86, 0xA1, 0x16, 0x1E, 0x45, 0xF9,
+        0x5A, 0x3E, 0xAA, 0x5C, 0x10, 0x12, 0xE6, 0x66,
+        0x2E, 0x44, 0xF1, 0x5F, 0x33, 0x5A, 0xC9, 0x71, 
+        0xE1, 0x76, 0x6B, 0x2B, 0xB9, 0xC9, 0x85, 0x10, 
+        0x99, 0x74, 0x14, 0x1B, 0x44, 0xD3, 0x7E, 0x1E, 
+        0x31, 0x98, 0x20, 0xA5, 0x5F, 0x02, 0x81, 0x81, 
+        0x00, 0xB2, 0x87, 0x12, 0x37, 0xBF, 0x9F, 0xAD, 
+        0x38, 0xC3, 0x31, 0x6A, 0xB7, 0x87, 0x7A, 0x6A, 
+        0x86, 0x80, 0x63, 0xE5, 0x42, 0xA7, 0x18, 0x6D, 
+        0x43, 0x1E, 0x8D, 0x27, 0xC1, 0x9A, 0xC0, 0x41, 
+        0x45, 0x84, 0x03, 0x39, 0x42, 0xE9, 0xFF, 0x6E, 
+        0x29, 0x73, 0xBB, 0x7B, 0x2D, 0x8B, 0x0E, 0x94, 
+        0xAD, 0x1E, 0xE8, 0x21, 0x58, 0x10, 0x8F, 0xBC,
+        0x86, 0x64, 0x51, 0x7A, 0x5A, 0x46, 0x7F, 0xB9, 
+        0x63, 0x01, 0x4B, 0xD5, 0xDC, 0xC2, 0xB4, 0xFB, 
+        0x08, 0x7C, 0x23, 0x03, 0x9D, 0x11, 0x92, 0x0D, 
+        0xBE, 0x22, 0xFD, 0x9F, 0x16, 0xB4, 0xD8, 0x9E, 
+        0x23, 0x22, 0x5C, 0xD4, 0x55, 0xAD, 0xBA, 0xF3, 
+        0x2E, 0xF4, 0x3F, 0x18, 0x58, 0x64, 0xA3, 0x6D,
+        0x63, 0x03, 0x09, 0xD6, 0x85, 0x3F, 0x77, 0x14,
+        0xB3, 0x9A, 0xAE, 0x1E, 0xBE, 0xE3, 0x93, 0x8F, 
+        0x87, 0xC2, 0x70, 0x7E, 0x17, 0x8C, 0x73, 0x9F, 
+        0x9F, 0x02, 0x81, 0x81, 0x00, 0x96, 0x90, 0xBE,
+        0xD1, 0x4B, 0x2A, 0xFA, 0xA2, 0x6D, 0x98, 0x6D, 
+        0x59, 0x22, 0x31, 0xEE, 0x27, 0xD7, 0x1D, 0x49, 
+        0x06, 0x5B, 0xD2, 0xBA, 0x1F, 0x78, 0x15, 0x7E, 
+        0x20, 0x22, 0x98, 0x81, 0xFD, 0x9D, 0x23, 0x22, 
+        0x7D, 0x0F, 0x84, 0x79, 0xEA, 0xEF, 0xA9, 0x22, 
+        0xFD, 0x75, 0xD5, 0xB1, 0x6B, 0x1A, 0x56, 0x1F,
+        0xA6, 0x68, 0x0B, 0x04, 0x0C, 0xA0, 0xBD, 0xCE, 
+        0x65, 0x0B, 0x23, 0xB9, 0x17, 0xA4, 0xB1, 0xBB, 
+        0x79, 0x83, 0xA7, 0x4F, 0xAD, 0x70, 0xE1, 0xC3, 
+        0x05, 0xCB, 0xEC, 0x2B, 0xFF, 0x1A, 0x85, 0xA7,
+        0x26, 0xA1, 0xD9, 0x02, 0x60, 0xE4, 0xF1, 0x08, 
+        0x4F, 0x51, 0x82, 0x34, 0xDC, 0xD3, 0xFE, 0x77, 
+        0x0B, 0x95, 0x20, 0x21, 0x5B, 0xD5, 0x43, 0xBB, 
+        0x6A, 0x41, 0x17, 0x71, 0x87, 0x54, 0x67, 0x6A, 
+        0x34, 0x17, 0x16, 0x66, 0xA7, 0x9F, 0x26, 0xE7, 
+        0x9C, 0x14, 0x9C, 0x5A, 0xA1, 0x02, 0x81, 0x81, 
+        0x00, 0xA0, 0xC9, 0x85, 0xA0, 0xA0, 0xA7, 0x91, 
+        0xA6, 0x59, 0xF9, 0x97, 0x31, 0x13, 0x4C, 0x44, 
+        0xF3, 0x7B, 0x2E, 0x52, 0x0A, 0x2C, 0xEA, 0x35, 
+        0x80, 0x0A, 0xD2, 0x72, 0x41, 0xED, 0x36, 0x0D, 
+        0xFD, 0xE6, 0xE8, 0xCA, 0x61, 0x4F, 0x12, 0x04, 
+        0x7F, 0xD0, 0x8B, 0x76, 0xAC, 0x4D, 0x13, 0xC0, 
+        0x56, 0xA0, 0x69, 0x9E, 0x2F, 0x98, 0xA1, 0xCA, 
+        0xC9, 0x10, 0x11, 0x29, 0x4D, 0x71, 0x20, 0x8F, 
+        0x4A, 0xBA, 0xB3, 0x3B, 0xA8, 0x7A, 0xA0, 0x51, 
+        0x7F, 0x41, 0x5B, 0xAC, 0xA8, 0x8D, 0x6B, 0xAC, 
+        0x00, 0x60, 0x88, 0xFA, 0x60, 0x1D, 0x34, 0x94, 
+        0x17, 0xE1, 0xF0, 0xC9, 0xB2, 0x3A, 0xFF, 0xA4, 
+        0xD4, 0x96, 0x61, 0x8D, 0xBC, 0x02, 0x49, 0x86, 
+        0xED, 0x69, 0x0B, 0xBB, 0x7B, 0x02, 0x57, 0x68, 
+        0xFF, 0x9D, 0xF8, 0xAC, 0x15, 0x41, 0x6F, 0x48, 
+        0x9F, 0x81, 0x29, 0xC3, 0x23, 0x41, 0xA8, 0xB4, 
+        0x4F
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &key;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_PKCS1;
+    kb.key_value = &kv;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_RSA;
+    kb.cryptographic_length = 2048;
+    
+    struct private_key pk = {0};
+    pk.key_block = &kb;
+    
+    int result = kmip_encode_private_key(&ctx, &pk);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_private_key(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[1280] = {
+        0x42, 0x00, 0x64, 0x01, 0x00, 0x00, 0x04, 0xF8, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x04, 0xF0, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x04, 0xB8, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x04, 0xA9,
+        0x30, 0x82, 0x04, 0xA5, 0x02, 0x01, 0x00, 0x02, 
+        0x82, 0x01, 0x01, 0x00, 0xAB, 0x7F, 0x16, 0x1C, 
+        0x00, 0x42, 0x49, 0x6C, 0xCD, 0x6C, 0x6D, 0x4D, 
+        0xAD, 0xB9, 0x19, 0x97, 0x34, 0x35, 0x35, 0x77, 
+        0x76, 0x00, 0x3A, 0xCF, 0x54, 0xB7, 0xAF, 0x1E, 
+        0x44, 0x0A, 0xFB, 0x80, 0xB6, 0x4A, 0x87, 0x55, 
+        0xF8, 0x00, 0x2C, 0xFE, 0xBA, 0x6B, 0x18, 0x45, 
+        0x40, 0xA2, 0xD6, 0x60, 0x86, 0xD7, 0x46, 0x48, 
+        0x34, 0x6D, 0x75, 0xB8, 0xD7, 0x18, 0x12, 0xB2, 
+        0x05, 0x38, 0x7C, 0x0F, 0x65, 0x83, 0xBC, 0x4D, 
+        0x7D, 0xC7, 0xEC, 0x11, 0x4F, 0x3B, 0x17, 0x6B, 
+        0x79, 0x57, 0xC4, 0x22, 0xE7, 0xD0, 0x3F, 0xC6,
+        0x26, 0x7F, 0xA2, 0xA6, 0xF8, 0x9B, 0x9B, 0xEE, 
+        0x9E, 0x60, 0xA1, 0xD7, 0xC2, 0xD8, 0x33, 0xE5, 
+        0xA5, 0xF4, 0xBB, 0x0B, 0x14, 0x34, 0xF4, 0xE7, 
+        0x95, 0xA4, 0x11, 0x00, 0xF8, 0xAA, 0x21, 0x49, 
+        0x00, 0xDF, 0x8B, 0x65, 0x08, 0x9F, 0x98, 0x13, 
+        0x5B, 0x1C, 0x67, 0xB7, 0x01, 0x67, 0x5A, 0xBD, 
+        0xBC, 0x7D, 0x57, 0x21, 0xAA, 0xC9, 0xD1, 0x4A, 
+        0x7F, 0x08, 0x1F, 0xCE, 0xC8, 0x0B, 0x64, 0xE8, 
+        0xA0, 0xEC, 0xC8, 0x29, 0x53, 0x53, 0xC7, 0x95, 
+        0x32, 0x8A, 0xBF, 0x70, 0xE1, 0xB4, 0x2E, 0x7B, 
+        0xB8, 0xB7, 0xF4, 0xE8, 0xAC, 0x8C, 0x81, 0x0C, 
+        0xDB, 0x66, 0xE3, 0xD2, 0x11, 0x26, 0xEB, 0xA8, 
+        0xDA, 0x7D, 0x0C, 0xA3, 0x41, 0x42, 0xCB, 0x76, 
+        0xF9, 0x1F, 0x01, 0x3D, 0xA8, 0x09, 0xE9, 0xC1, 
+        0xB7, 0xAE, 0x64, 0xC5, 0x41, 0x30, 0xFB, 0xC2, 
+        0x1D, 0x80, 0xE9, 0xC2, 0xCB, 0x06, 0xC5, 0xC8, 
+        0xD7, 0xCC, 0xE8, 0x94, 0x6A, 0x9A, 0xC9, 0x9B,
+        0x1C, 0x28, 0x15, 0xC3, 0x61, 0x2A, 0x29, 0xA8, 
+        0x2D, 0x73, 0xA1, 0xF9, 0x93, 0x74, 0xFE, 0x30, 
+        0xE5, 0x49, 0x51, 0x66, 0x2A, 0x6E, 0xDA, 0x29, 
+        0xC6, 0xFC, 0x41, 0x13, 0x35, 0xD5, 0xDC, 0x74, 
+        0x26, 0xB0, 0xF6, 0x05, 0x02, 0x03, 0x01, 0x00, 
+        0x01, 0x02, 0x82, 0x01, 0x00, 0x3B, 0x12, 0x45, 
+        0x5D, 0x53, 0xC1, 0x81, 0x65, 0x16, 0xC5, 0x18, 
+        0x49, 0x3F, 0x63, 0x98, 0xAA, 0xFA, 0x72, 0xB1, 
+        0x7D, 0xFA, 0x89, 0x4D, 0xB8, 0x88, 0xA7, 0xD4, 
+        0x8C, 0x0A, 0x47, 0xF6, 0x25, 0x79, 0xA4, 0xE6, 
+        0x44, 0xF8, 0x6D, 0xA7, 0x11, 0xFE, 0xC8, 0x50, 
+        0xCD, 0xD9, 0xDB, 0xBD, 0x17, 0xF6, 0x9A, 0x44, 
+        0x3D, 0x2E, 0xC1, 0xDD, 0x60, 0xD3, 0xC6, 0x18, 
+        0xFA, 0x74, 0xCD, 0xE5, 0xFD, 0xAF, 0xAB, 0xD6, 
+        0xBA, 0xA2, 0x6E, 0xB0, 0xA3, 0xAD, 0xB4, 0xDE, 
+        0xF6, 0x48, 0x0F, 0xB1, 0x21, 0x8C, 0xD3, 0xB0,
+        0x83, 0xE2, 0x52, 0xE8, 0x85, 0xB6, 0xF0, 0x72, 
+        0x9F, 0x98, 0xB2, 0x14, 0x4D, 0x2B, 0x72, 0x29, 
+        0x3E, 0x1B, 0x11, 0xD7, 0x33, 0x93, 0xBC, 0x41, 
+        0xF7, 0x5B, 0x15, 0xEE, 0x3D, 0x75, 0x69, 0xB4, 
+        0x99, 0x5E, 0xD1, 0xA1, 0x44, 0x25, 0xDA, 0x43, 
+        0x19, 0xB7, 0xB2, 0x6B, 0x0E, 0x8F, 0xEF, 0x17, 
+        0xC3, 0x75, 0x42, 0xAE, 0x5C, 0x6D, 0x58, 0x49, 
+        0xF8, 0x72, 0x09, 0x56, 0x7F, 0x39, 0x25, 0xA4, 
+        0x7B, 0x01, 0x6D, 0x56, 0x48, 0x59, 0x71, 0x7B, 
+        0xC5, 0x7F, 0xCB, 0x45, 0x22, 0xD0, 0xAA, 0x49, 
+        0xCE, 0x81, 0x6E, 0x5B, 0xE7, 0xB3, 0x08, 0x81, 
+        0x93, 0x23, 0x6E, 0xC9, 0xEF, 0xFF, 0x14, 0x08, 
+        0x58, 0x04, 0x5B, 0x73, 0xC5, 0xD7, 0x9B, 0xAF, 
+        0x38, 0xF7, 0xC6, 0x7F, 0x04, 0xC5, 0xDC, 0xF0, 
+        0xE3, 0x80, 0x6A, 0xD9, 0x82, 0xD1, 0x25, 0x90, 
+        0x58, 0xC3, 0x47, 0x3E, 0x84, 0x71, 0x79, 0xA8, 
+        0x78, 0xF2, 0xC6, 0xB3, 0xBD, 0x96, 0x8F, 0xB9,
+        0x9E, 0xA4, 0x6E, 0x91, 0x85, 0x89, 0x2F, 0x36,
+        0x76, 0xE7, 0x89, 0x65, 0xC2, 0xAE, 0xD4, 0x87,
+        0x7B, 0xA3, 0x91, 0x7D, 0xF0, 0x7C, 0x5E, 0x92, 
+        0x74, 0x74, 0xF1, 0x9E, 0x76, 0x4B, 0xA6, 0x1D, 
+        0xC3, 0x8D, 0x63, 0xBF, 0x29, 0x02, 0x81, 0x81, 
+        0x00, 0xD5, 0xC6, 0x9C, 0x8C, 0x3C, 0xDC, 0x24, 
+        0x64, 0x74, 0x4A, 0x79, 0x37, 0x13, 0xDA, 0xFB, 
+        0x9F, 0x1D, 0xBC, 0x79, 0x9F, 0xF9, 0x64, 0x23, 
+        0xFE, 0xCD, 0x3C, 0xBA, 0x79, 0x42, 0x86, 0xBC, 
+        0xE9, 0x20, 0xF4, 0xB5, 0xC1, 0x83, 0xF9, 0x9E, 
+        0xE9, 0x02, 0x8D, 0xB6, 0x21, 0x2C, 0x62, 0x77, 
+        0xC4, 0xC8, 0x29, 0x7F, 0xCF, 0xBC, 0xE7, 0xF7,
+        0xC2, 0x4C, 0xA4, 0xC5, 0x1F, 0xC7, 0x18, 0x2F, 
+        0xB8, 0xF4, 0x01, 0x9F, 0xB1, 0xD5, 0x65, 0x96, 
+        0x74, 0xC5, 0xCB, 0xE6, 0xD5, 0xFA, 0x99, 0x20, 
+        0x51, 0x34, 0x17, 0x60, 0xCD, 0x00, 0x73, 0x57, 
+        0x29, 0xA0, 0x70, 0xA9, 0xE5, 0x4D, 0x34, 0x2B, 
+        0xEB, 0xA8, 0xEF, 0x47, 0xEE, 0x82, 0xD3, 0xA0, 
+        0x1B, 0x04, 0xCE, 0xC4, 0xA0, 0x0D, 0x4D, 0xDB,
+        0x41, 0xE3, 0x51, 0x16, 0xFC, 0x22, 0x1E, 0x85, 
+        0x4B, 0x43, 0xA6, 0x96, 0xC0, 0xE6, 0x41, 0x9B, 
+        0x1B, 0x02, 0x81, 0x81, 0x00, 0xCD, 0x5E, 0xA7, 
+        0x70, 0x27, 0x89, 0x06, 0x4B, 0x67, 0x35, 0x40, 
+        0xCB, 0xFF, 0x09, 0x35, 0x6A, 0xD8, 0x0B, 0xC3, 
+        0xD5, 0x92, 0x81, 0x2E, 0xBA, 0x47, 0x61, 0x0B,
+        0x9F, 0xAC, 0x6A, 0xEC, 0xEF, 0xE2, 0x2A, 0xCA, 
+        0xE4, 0x38, 0x45, 0x9C, 0xDA, 0x74, 0xE5, 0x96, 
+        0x53, 0xD8, 0x8C, 0x04, 0x18, 0x9D, 0x34, 0x39, 
+        0x9B, 0xF5, 0xB1, 0x4B, 0x92, 0x0E, 0x34, 0xEF, 
+        0x38, 0xA7, 0xD0, 0x9F, 0xE6, 0x95, 0x93, 0x39, 
+        0x6E, 0x8F, 0xE7, 0x35, 0xE6, 0xF0, 0xA6, 0xAE, 
+        0x49, 0x90, 0x40, 0x10, 0x41, 0xD8, 0xA4, 0x06, 
+        0xB6, 0xFD, 0x86, 0xA1, 0x16, 0x1E, 0x45, 0xF9,
+        0x5A, 0x3E, 0xAA, 0x5C, 0x10, 0x12, 0xE6, 0x66,
+        0x2E, 0x44, 0xF1, 0x5F, 0x33, 0x5A, 0xC9, 0x71, 
+        0xE1, 0x76, 0x6B, 0x2B, 0xB9, 0xC9, 0x85, 0x10, 
+        0x99, 0x74, 0x14, 0x1B, 0x44, 0xD3, 0x7E, 0x1E, 
+        0x31, 0x98, 0x20, 0xA5, 0x5F, 0x02, 0x81, 0x81, 
+        0x00, 0xB2, 0x87, 0x12, 0x37, 0xBF, 0x9F, 0xAD, 
+        0x38, 0xC3, 0x31, 0x6A, 0xB7, 0x87, 0x7A, 0x6A, 
+        0x86, 0x80, 0x63, 0xE5, 0x42, 0xA7, 0x18, 0x6D, 
+        0x43, 0x1E, 0x8D, 0x27, 0xC1, 0x9A, 0xC0, 0x41, 
+        0x45, 0x84, 0x03, 0x39, 0x42, 0xE9, 0xFF, 0x6E, 
+        0x29, 0x73, 0xBB, 0x7B, 0x2D, 0x8B, 0x0E, 0x94, 
+        0xAD, 0x1E, 0xE8, 0x21, 0x58, 0x10, 0x8F, 0xBC,
+        0x86, 0x64, 0x51, 0x7A, 0x5A, 0x46, 0x7F, 0xB9, 
+        0x63, 0x01, 0x4B, 0xD5, 0xDC, 0xC2, 0xB4, 0xFB, 
+        0x08, 0x7C, 0x23, 0x03, 0x9D, 0x11, 0x92, 0x0D, 
+        0xBE, 0x22, 0xFD, 0x9F, 0x16, 0xB4, 0xD8, 0x9E, 
+        0x23, 0x22, 0x5C, 0xD4, 0x55, 0xAD, 0xBA, 0xF3, 
+        0x2E, 0xF4, 0x3F, 0x18, 0x58, 0x64, 0xA3, 0x6D,
+        0x63, 0x03, 0x09, 0xD6, 0x85, 0x3F, 0x77, 0x14,
+        0xB3, 0x9A, 0xAE, 0x1E, 0xBE, 0xE3, 0x93, 0x8F, 
+        0x87, 0xC2, 0x70, 0x7E, 0x17, 0x8C, 0x73, 0x9F, 
+        0x9F, 0x02, 0x81, 0x81, 0x00, 0x96, 0x90, 0xBE,
+        0xD1, 0x4B, 0x2A, 0xFA, 0xA2, 0x6D, 0x98, 0x6D, 
+        0x59, 0x22, 0x31, 0xEE, 0x27, 0xD7, 0x1D, 0x49, 
+        0x06, 0x5B, 0xD2, 0xBA, 0x1F, 0x78, 0x15, 0x7E, 
+        0x20, 0x22, 0x98, 0x81, 0xFD, 0x9D, 0x23, 0x22, 
+        0x7D, 0x0F, 0x84, 0x79, 0xEA, 0xEF, 0xA9, 0x22, 
+        0xFD, 0x75, 0xD5, 0xB1, 0x6B, 0x1A, 0x56, 0x1F,
+        0xA6, 0x68, 0x0B, 0x04, 0x0C, 0xA0, 0xBD, 0xCE, 
+        0x65, 0x0B, 0x23, 0xB9, 0x17, 0xA4, 0xB1, 0xBB, 
+        0x79, 0x83, 0xA7, 0x4F, 0xAD, 0x70, 0xE1, 0xC3, 
+        0x05, 0xCB, 0xEC, 0x2B, 0xFF, 0x1A, 0x85, 0xA7,
+        0x26, 0xA1, 0xD9, 0x02, 0x60, 0xE4, 0xF1, 0x08, 
+        0x4F, 0x51, 0x82, 0x34, 0xDC, 0xD3, 0xFE, 0x77, 
+        0x0B, 0x95, 0x20, 0x21, 0x5B, 0xD5, 0x43, 0xBB, 
+        0x6A, 0x41, 0x17, 0x71, 0x87, 0x54, 0x67, 0x6A, 
+        0x34, 0x17, 0x16, 0x66, 0xA7, 0x9F, 0x26, 0xE7, 
+        0x9C, 0x14, 0x9C, 0x5A, 0xA1, 0x02, 0x81, 0x81, 
+        0x00, 0xA0, 0xC9, 0x85, 0xA0, 0xA0, 0xA7, 0x91, 
+        0xA6, 0x59, 0xF9, 0x97, 0x31, 0x13, 0x4C, 0x44, 
+        0xF3, 0x7B, 0x2E, 0x52, 0x0A, 0x2C, 0xEA, 0x35, 
+        0x80, 0x0A, 0xD2, 0x72, 0x41, 0xED, 0x36, 0x0D, 
+        0xFD, 0xE6, 0xE8, 0xCA, 0x61, 0x4F, 0x12, 0x04, 
+        0x7F, 0xD0, 0x8B, 0x76, 0xAC, 0x4D, 0x13, 0xC0, 
+        0x56, 0xA0, 0x69, 0x9E, 0x2F, 0x98, 0xA1, 0xCA, 
+        0xC9, 0x10, 0x11, 0x29, 0x4D, 0x71, 0x20, 0x8F, 
+        0x4A, 0xBA, 0xB3, 0x3B, 0xA8, 0x7A, 0xA0, 0x51, 
+        0x7F, 0x41, 0x5B, 0xAC, 0xA8, 0x8D, 0x6B, 0xAC, 
+        0x00, 0x60, 0x88, 0xFA, 0x60, 0x1D, 0x34, 0x94, 
+        0x17, 0xE1, 0xF0, 0xC9, 0xB2, 0x3A, 0xFF, 0xA4, 
+        0xD4, 0x96, 0x61, 0x8D, 0xBC, 0x02, 0x49, 0x86, 
+        0xED, 0x69, 0x0B, 0xBB, 0x7B, 0x02, 0x57, 0x68, 
+        0xFF, 0x9D, 0xF8, 0xAC, 0x15, 0x41, 0x6F, 0x48, 
+        0x9F, 0x81, 0x29, 0xC3, 0x23, 0x41, 0xA8, 0xB4, 
+        0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    uint8 value[1193] = {
+        0x30, 0x82, 0x04, 0xA5, 0x02, 0x01, 0x00, 0x02, 
+        0x82, 0x01, 0x01, 0x00, 0xAB, 0x7F, 0x16, 0x1C, 
+        0x00, 0x42, 0x49, 0x6C, 0xCD, 0x6C, 0x6D, 0x4D, 
+        0xAD, 0xB9, 0x19, 0x97, 0x34, 0x35, 0x35, 0x77, 
+        0x76, 0x00, 0x3A, 0xCF, 0x54, 0xB7, 0xAF, 0x1E, 
+        0x44, 0x0A, 0xFB, 0x80, 0xB6, 0x4A, 0x87, 0x55, 
+        0xF8, 0x00, 0x2C, 0xFE, 0xBA, 0x6B, 0x18, 0x45, 
+        0x40, 0xA2, 0xD6, 0x60, 0x86, 0xD7, 0x46, 0x48, 
+        0x34, 0x6D, 0x75, 0xB8, 0xD7, 0x18, 0x12, 0xB2, 
+        0x05, 0x38, 0x7C, 0x0F, 0x65, 0x83, 0xBC, 0x4D, 
+        0x7D, 0xC7, 0xEC, 0x11, 0x4F, 0x3B, 0x17, 0x6B, 
+        0x79, 0x57, 0xC4, 0x22, 0xE7, 0xD0, 0x3F, 0xC6,
+        0x26, 0x7F, 0xA2, 0xA6, 0xF8, 0x9B, 0x9B, 0xEE, 
+        0x9E, 0x60, 0xA1, 0xD7, 0xC2, 0xD8, 0x33, 0xE5, 
+        0xA5, 0xF4, 0xBB, 0x0B, 0x14, 0x34, 0xF4, 0xE7, 
+        0x95, 0xA4, 0x11, 0x00, 0xF8, 0xAA, 0x21, 0x49, 
+        0x00, 0xDF, 0x8B, 0x65, 0x08, 0x9F, 0x98, 0x13, 
+        0x5B, 0x1C, 0x67, 0xB7, 0x01, 0x67, 0x5A, 0xBD, 
+        0xBC, 0x7D, 0x57, 0x21, 0xAA, 0xC9, 0xD1, 0x4A, 
+        0x7F, 0x08, 0x1F, 0xCE, 0xC8, 0x0B, 0x64, 0xE8, 
+        0xA0, 0xEC, 0xC8, 0x29, 0x53, 0x53, 0xC7, 0x95, 
+        0x32, 0x8A, 0xBF, 0x70, 0xE1, 0xB4, 0x2E, 0x7B, 
+        0xB8, 0xB7, 0xF4, 0xE8, 0xAC, 0x8C, 0x81, 0x0C, 
+        0xDB, 0x66, 0xE3, 0xD2, 0x11, 0x26, 0xEB, 0xA8, 
+        0xDA, 0x7D, 0x0C, 0xA3, 0x41, 0x42, 0xCB, 0x76, 
+        0xF9, 0x1F, 0x01, 0x3D, 0xA8, 0x09, 0xE9, 0xC1, 
+        0xB7, 0xAE, 0x64, 0xC5, 0x41, 0x30, 0xFB, 0xC2, 
+        0x1D, 0x80, 0xE9, 0xC2, 0xCB, 0x06, 0xC5, 0xC8, 
+        0xD7, 0xCC, 0xE8, 0x94, 0x6A, 0x9A, 0xC9, 0x9B,
+        0x1C, 0x28, 0x15, 0xC3, 0x61, 0x2A, 0x29, 0xA8, 
+        0x2D, 0x73, 0xA1, 0xF9, 0x93, 0x74, 0xFE, 0x30, 
+        0xE5, 0x49, 0x51, 0x66, 0x2A, 0x6E, 0xDA, 0x29, 
+        0xC6, 0xFC, 0x41, 0x13, 0x35, 0xD5, 0xDC, 0x74, 
+        0x26, 0xB0, 0xF6, 0x05, 0x02, 0x03, 0x01, 0x00, 
+        0x01, 0x02, 0x82, 0x01, 0x00, 0x3B, 0x12, 0x45, 
+        0x5D, 0x53, 0xC1, 0x81, 0x65, 0x16, 0xC5, 0x18, 
+        0x49, 0x3F, 0x63, 0x98, 0xAA, 0xFA, 0x72, 0xB1, 
+        0x7D, 0xFA, 0x89, 0x4D, 0xB8, 0x88, 0xA7, 0xD4, 
+        0x8C, 0x0A, 0x47, 0xF6, 0x25, 0x79, 0xA4, 0xE6, 
+        0x44, 0xF8, 0x6D, 0xA7, 0x11, 0xFE, 0xC8, 0x50, 
+        0xCD, 0xD9, 0xDB, 0xBD, 0x17, 0xF6, 0x9A, 0x44, 
+        0x3D, 0x2E, 0xC1, 0xDD, 0x60, 0xD3, 0xC6, 0x18, 
+        0xFA, 0x74, 0xCD, 0xE5, 0xFD, 0xAF, 0xAB, 0xD6, 
+        0xBA, 0xA2, 0x6E, 0xB0, 0xA3, 0xAD, 0xB4, 0xDE, 
+        0xF6, 0x48, 0x0F, 0xB1, 0x21, 0x8C, 0xD3, 0xB0,
+        0x83, 0xE2, 0x52, 0xE8, 0x85, 0xB6, 0xF0, 0x72, 
+        0x9F, 0x98, 0xB2, 0x14, 0x4D, 0x2B, 0x72, 0x29, 
+        0x3E, 0x1B, 0x11, 0xD7, 0x33, 0x93, 0xBC, 0x41, 
+        0xF7, 0x5B, 0x15, 0xEE, 0x3D, 0x75, 0x69, 0xB4, 
+        0x99, 0x5E, 0xD1, 0xA1, 0x44, 0x25, 0xDA, 0x43, 
+        0x19, 0xB7, 0xB2, 0x6B, 0x0E, 0x8F, 0xEF, 0x17, 
+        0xC3, 0x75, 0x42, 0xAE, 0x5C, 0x6D, 0x58, 0x49, 
+        0xF8, 0x72, 0x09, 0x56, 0x7F, 0x39, 0x25, 0xA4, 
+        0x7B, 0x01, 0x6D, 0x56, 0x48, 0x59, 0x71, 0x7B, 
+        0xC5, 0x7F, 0xCB, 0x45, 0x22, 0xD0, 0xAA, 0x49, 
+        0xCE, 0x81, 0x6E, 0x5B, 0xE7, 0xB3, 0x08, 0x81, 
+        0x93, 0x23, 0x6E, 0xC9, 0xEF, 0xFF, 0x14, 0x08, 
+        0x58, 0x04, 0x5B, 0x73, 0xC5, 0xD7, 0x9B, 0xAF, 
+        0x38, 0xF7, 0xC6, 0x7F, 0x04, 0xC5, 0xDC, 0xF0, 
+        0xE3, 0x80, 0x6A, 0xD9, 0x82, 0xD1, 0x25, 0x90, 
+        0x58, 0xC3, 0x47, 0x3E, 0x84, 0x71, 0x79, 0xA8, 
+        0x78, 0xF2, 0xC6, 0xB3, 0xBD, 0x96, 0x8F, 0xB9,
+        0x9E, 0xA4, 0x6E, 0x91, 0x85, 0x89, 0x2F, 0x36,
+        0x76, 0xE7, 0x89, 0x65, 0xC2, 0xAE, 0xD4, 0x87,
+        0x7B, 0xA3, 0x91, 0x7D, 0xF0, 0x7C, 0x5E, 0x92, 
+        0x74, 0x74, 0xF1, 0x9E, 0x76, 0x4B, 0xA6, 0x1D, 
+        0xC3, 0x8D, 0x63, 0xBF, 0x29, 0x02, 0x81, 0x81, 
+        0x00, 0xD5, 0xC6, 0x9C, 0x8C, 0x3C, 0xDC, 0x24, 
+        0x64, 0x74, 0x4A, 0x79, 0x37, 0x13, 0xDA, 0xFB, 
+        0x9F, 0x1D, 0xBC, 0x79, 0x9F, 0xF9, 0x64, 0x23, 
+        0xFE, 0xCD, 0x3C, 0xBA, 0x79, 0x42, 0x86, 0xBC, 
+        0xE9, 0x20, 0xF4, 0xB5, 0xC1, 0x83, 0xF9, 0x9E, 
+        0xE9, 0x02, 0x8D, 0xB6, 0x21, 0x2C, 0x62, 0x77, 
+        0xC4, 0xC8, 0x29, 0x7F, 0xCF, 0xBC, 0xE7, 0xF7,
+        0xC2, 0x4C, 0xA4, 0xC5, 0x1F, 0xC7, 0x18, 0x2F, 
+        0xB8, 0xF4, 0x01, 0x9F, 0xB1, 0xD5, 0x65, 0x96, 
+        0x74, 0xC5, 0xCB, 0xE6, 0xD5, 0xFA, 0x99, 0x20, 
+        0x51, 0x34, 0x17, 0x60, 0xCD, 0x00, 0x73, 0x57, 
+        0x29, 0xA0, 0x70, 0xA9, 0xE5, 0x4D, 0x34, 0x2B, 
+        0xEB, 0xA8, 0xEF, 0x47, 0xEE, 0x82, 0xD3, 0xA0, 
+        0x1B, 0x04, 0xCE, 0xC4, 0xA0, 0x0D, 0x4D, 0xDB,
+        0x41, 0xE3, 0x51, 0x16, 0xFC, 0x22, 0x1E, 0x85, 
+        0x4B, 0x43, 0xA6, 0x96, 0xC0, 0xE6, 0x41, 0x9B, 
+        0x1B, 0x02, 0x81, 0x81, 0x00, 0xCD, 0x5E, 0xA7, 
+        0x70, 0x27, 0x89, 0x06, 0x4B, 0x67, 0x35, 0x40, 
+        0xCB, 0xFF, 0x09, 0x35, 0x6A, 0xD8, 0x0B, 0xC3, 
+        0xD5, 0x92, 0x81, 0x2E, 0xBA, 0x47, 0x61, 0x0B,
+        0x9F, 0xAC, 0x6A, 0xEC, 0xEF, 0xE2, 0x2A, 0xCA, 
+        0xE4, 0x38, 0x45, 0x9C, 0xDA, 0x74, 0xE5, 0x96, 
+        0x53, 0xD8, 0x8C, 0x04, 0x18, 0x9D, 0x34, 0x39, 
+        0x9B, 0xF5, 0xB1, 0x4B, 0x92, 0x0E, 0x34, 0xEF, 
+        0x38, 0xA7, 0xD0, 0x9F, 0xE6, 0x95, 0x93, 0x39, 
+        0x6E, 0x8F, 0xE7, 0x35, 0xE6, 0xF0, 0xA6, 0xAE, 
+        0x49, 0x90, 0x40, 0x10, 0x41, 0xD8, 0xA4, 0x06, 
+        0xB6, 0xFD, 0x86, 0xA1, 0x16, 0x1E, 0x45, 0xF9,
+        0x5A, 0x3E, 0xAA, 0x5C, 0x10, 0x12, 0xE6, 0x66,
+        0x2E, 0x44, 0xF1, 0x5F, 0x33, 0x5A, 0xC9, 0x71, 
+        0xE1, 0x76, 0x6B, 0x2B, 0xB9, 0xC9, 0x85, 0x10, 
+        0x99, 0x74, 0x14, 0x1B, 0x44, 0xD3, 0x7E, 0x1E, 
+        0x31, 0x98, 0x20, 0xA5, 0x5F, 0x02, 0x81, 0x81, 
+        0x00, 0xB2, 0x87, 0x12, 0x37, 0xBF, 0x9F, 0xAD, 
+        0x38, 0xC3, 0x31, 0x6A, 0xB7, 0x87, 0x7A, 0x6A, 
+        0x86, 0x80, 0x63, 0xE5, 0x42, 0xA7, 0x18, 0x6D, 
+        0x43, 0x1E, 0x8D, 0x27, 0xC1, 0x9A, 0xC0, 0x41, 
+        0x45, 0x84, 0x03, 0x39, 0x42, 0xE9, 0xFF, 0x6E, 
+        0x29, 0x73, 0xBB, 0x7B, 0x2D, 0x8B, 0x0E, 0x94, 
+        0xAD, 0x1E, 0xE8, 0x21, 0x58, 0x10, 0x8F, 0xBC,
+        0x86, 0x64, 0x51, 0x7A, 0x5A, 0x46, 0x7F, 0xB9, 
+        0x63, 0x01, 0x4B, 0xD5, 0xDC, 0xC2, 0xB4, 0xFB, 
+        0x08, 0x7C, 0x23, 0x03, 0x9D, 0x11, 0x92, 0x0D, 
+        0xBE, 0x22, 0xFD, 0x9F, 0x16, 0xB4, 0xD8, 0x9E, 
+        0x23, 0x22, 0x5C, 0xD4, 0x55, 0xAD, 0xBA, 0xF3, 
+        0x2E, 0xF4, 0x3F, 0x18, 0x58, 0x64, 0xA3, 0x6D,
+        0x63, 0x03, 0x09, 0xD6, 0x85, 0x3F, 0x77, 0x14,
+        0xB3, 0x9A, 0xAE, 0x1E, 0xBE, 0xE3, 0x93, 0x8F, 
+        0x87, 0xC2, 0x70, 0x7E, 0x17, 0x8C, 0x73, 0x9F, 
+        0x9F, 0x02, 0x81, 0x81, 0x00, 0x96, 0x90, 0xBE,
+        0xD1, 0x4B, 0x2A, 0xFA, 0xA2, 0x6D, 0x98, 0x6D, 
+        0x59, 0x22, 0x31, 0xEE, 0x27, 0xD7, 0x1D, 0x49, 
+        0x06, 0x5B, 0xD2, 0xBA, 0x1F, 0x78, 0x15, 0x7E, 
+        0x20, 0x22, 0x98, 0x81, 0xFD, 0x9D, 0x23, 0x22, 
+        0x7D, 0x0F, 0x84, 0x79, 0xEA, 0xEF, 0xA9, 0x22, 
+        0xFD, 0x75, 0xD5, 0xB1, 0x6B, 0x1A, 0x56, 0x1F,
+        0xA6, 0x68, 0x0B, 0x04, 0x0C, 0xA0, 0xBD, 0xCE, 
+        0x65, 0x0B, 0x23, 0xB9, 0x17, 0xA4, 0xB1, 0xBB, 
+        0x79, 0x83, 0xA7, 0x4F, 0xAD, 0x70, 0xE1, 0xC3, 
+        0x05, 0xCB, 0xEC, 0x2B, 0xFF, 0x1A, 0x85, 0xA7,
+        0x26, 0xA1, 0xD9, 0x02, 0x60, 0xE4, 0xF1, 0x08, 
+        0x4F, 0x51, 0x82, 0x34, 0xDC, 0xD3, 0xFE, 0x77, 
+        0x0B, 0x95, 0x20, 0x21, 0x5B, 0xD5, 0x43, 0xBB, 
+        0x6A, 0x41, 0x17, 0x71, 0x87, 0x54, 0x67, 0x6A, 
+        0x34, 0x17, 0x16, 0x66, 0xA7, 0x9F, 0x26, 0xE7, 
+        0x9C, 0x14, 0x9C, 0x5A, 0xA1, 0x02, 0x81, 0x81, 
+        0x00, 0xA0, 0xC9, 0x85, 0xA0, 0xA0, 0xA7, 0x91, 
+        0xA6, 0x59, 0xF9, 0x97, 0x31, 0x13, 0x4C, 0x44, 
+        0xF3, 0x7B, 0x2E, 0x52, 0x0A, 0x2C, 0xEA, 0x35, 
+        0x80, 0x0A, 0xD2, 0x72, 0x41, 0xED, 0x36, 0x0D, 
+        0xFD, 0xE6, 0xE8, 0xCA, 0x61, 0x4F, 0x12, 0x04, 
+        0x7F, 0xD0, 0x8B, 0x76, 0xAC, 0x4D, 0x13, 0xC0, 
+        0x56, 0xA0, 0x69, 0x9E, 0x2F, 0x98, 0xA1, 0xCA, 
+        0xC9, 0x10, 0x11, 0x29, 0x4D, 0x71, 0x20, 0x8F, 
+        0x4A, 0xBA, 0xB3, 0x3B, 0xA8, 0x7A, 0xA0, 0x51, 
+        0x7F, 0x41, 0x5B, 0xAC, 0xA8, 0x8D, 0x6B, 0xAC, 
+        0x00, 0x60, 0x88, 0xFA, 0x60, 0x1D, 0x34, 0x94, 
+        0x17, 0xE1, 0xF0, 0xC9, 0xB2, 0x3A, 0xFF, 0xA4, 
+        0xD4, 0x96, 0x61, 0x8D, 0xBC, 0x02, 0x49, 0x86, 
+        0xED, 0x69, 0x0B, 0xBB, 0x7B, 0x02, 0x57, 0x68, 
+        0xFF, 0x9D, 0xF8, 0xAC, 0x15, 0x41, 0x6F, 0x48, 
+        0x9F, 0x81, 0x29, 0xC3, 0x23, 0x41, 0xA8, 0xB4, 
+        0x4F
+    };
+    struct byte_string key = {0};
+    key.value = value;
+    key.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &key;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_PKCS1;
+    kb.key_value = &kv;
+    kb.key_value_type = KMIP_TYPE_STRUCTURE;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_RSA;
+    kb.cryptographic_length = 2048;
+    
+    struct private_key expected = {0};
+    expected.key_block = &kb;
+    
+    struct private_key observed = {0};
+    
+    int result = kmip_decode_private_key(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_private_key(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_private_key(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_key_wrapping_specification(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[136] = {
+        0x42, 0x00, 0x47, 0x01, 0x00, 0x00, 0x00, 0x80, 
+        0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x34, 0x62, 0x32, 0x62, 0x34, 0x63, 0x33, 
+        0x2D, 0x34, 0x63, 0x31, 0x39, 0x2D, 0x34, 0x65, 
+        0x63, 0x66, 0x2D, 0x38, 0x32, 0x37, 0x61, 0x2D, 
+        0x30, 0x31, 0x31, 0x63, 0x61, 0x36, 0x30, 0x35, 
+        0x37, 0x64, 0x33, 0x65, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B
+    };
+    
+    uint8 observed[136] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "f4b2b4c3-4c19-4ecf-827a-011ca6057d3e";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    struct text_string attribute_name = {0};
+    attribute_name.value = "Cryptographic Usage Mask";
+    attribute_name.size = 24;
+    
+    struct key_wrapping_specification kws = {0};
+    kws.wrapping_method = KMIP_WRAP_ENCRYPT;
+    kws.encryption_key_info = &eki;
+    kws.attribute_names = &attribute_name;
+    kws.attribute_name_count = 1;
+    
+    int result = kmip_encode_key_wrapping_specification(&ctx, &kws);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_key_wrapping_specification(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[136] = {
+        0x42, 0x00, 0x47, 0x01, 0x00, 0x00, 0x00, 0x80, 
+        0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x34, 0x62, 0x32, 0x62, 0x34, 0x63, 0x33, 
+        0x2D, 0x34, 0x63, 0x31, 0x39, 0x2D, 0x34, 0x65, 
+        0x63, 0x66, 0x2D, 0x38, 0x32, 0x37, 0x61, 0x2D, 
+        0x30, 0x31, 0x31, 0x63, 0x61, 0x36, 0x30, 0x35, 
+        0x37, 0x64, 0x33, 0x65, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "f4b2b4c3-4c19-4ecf-827a-011ca6057d3e";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    kmip_init_cryptographic_parameters(&cp);
+    
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    struct text_string attribute_name = {0};
+    attribute_name.value = "Cryptographic Usage Mask";
+    attribute_name.size = 24;
+    
+    struct key_wrapping_specification expected = {0};
+    expected.wrapping_method = KMIP_WRAP_ENCRYPT;
+    expected.encryption_key_info = &eki;
+    expected.attribute_names = &attribute_name;
+    expected.attribute_name_count = 1;
+    
+    struct key_wrapping_specification observed = {0};
+    
+    int result = kmip_decode_key_wrapping_specification(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_key_wrapping_specification(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_key_wrapping_specification(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_create_request_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Request Payload
+    *      Object Type - Symmetric Key
+    *      Template Attribute
+    *          Attribute
+    *              Attribute Name - Cryptographic Algorithm
+    *              Attribute Value - AES
+    *          Attribute
+    *              Attribute Name - Cryptographic Length
+    *              Attribute Value - 128
+    *          Attribute
+    *              Attribute Name - Cryptographic Usage Mask
+    *              Attribute Value - Encrypt | Decrypt
+    */
+    uint8 expected[200] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0xC0, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0xA8, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, 
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, 
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, 
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[200] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct attribute a[3] = {0};
+    for(int i = 0; i < 3; i++)
+    {
+        kmip_init_attribute(&a[i]);
+    }
+    
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    a[0].value = &algorithm;
+    
+    int32 length = 128;
+    a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    a[1].value = &length;
+    
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    a[2].value = &mask;
+    
+    struct template_attribute ta = {0};
+    ta.attributes = a;
+    ta.attribute_count = ARRAY_LENGTH(a);
+    
+    struct create_request_payload crp = {0};
+    crp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    crp.template_attribute = &ta;
+    
+    int result = kmip_encode_create_request_payload(&ctx, &crp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_create_request_payload_kmip_2_0(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Request Payload
+    *      Object Type - Symmetric Key
+    *      Attributes
+    *          Cryptographic Algorithm - AES
+    *          Cryptographic Length - 128
+    *          Cryptographic Usage Mask - Encrypt | Decrypt
+    *      Protection Storage Masks
+    *          Protection Storage Mask - Software | On System
+    *          Protection Storage Mask - Off System | Off Premises
+    */
+    uint8 expected[120] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x70, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x25, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x5F, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[120] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+    
+    Attribute a[3] = {0};
+    for(int i = 0; i < 3; i++)
+    {
+        kmip_init_attribute(&a[i]);
+    }
+    
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    a[0].value = &algorithm;
+    
+    int32 length = 128;
+    a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    a[1].value = &length;
+    
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    a[2].value = &mask;
+    
+    Attributes attributes = {0};
+    LinkedList list = {0};
+    LinkedListItem item_1, item_2, item_3 = {0};
+    item_1.data = &a[0];
+    item_2.data = &a[1];
+    item_3.data = &a[2];
+    kmip_linked_list_enqueue(&list, &item_1);
+    kmip_linked_list_enqueue(&list, &item_2);
+    kmip_linked_list_enqueue(&list, &item_3);
+    attributes.attribute_list = &list;
+
+    ProtectionStorageMasks psm = {0};
+    LinkedList masks = {0};
+    LinkedListItem mask_1, mask_2 = {0};
+    int32 m1 = KMIP_PROTECT_SOFTWARE | KMIP_PROTECT_ON_SYSTEM;
+    int32 m2 = KMIP_PROTECT_OFF_SYSTEM | KMIP_PROTECT_OFF_PREMISES;
+    mask_1.data = &m1;
+    mask_2.data = &m2;
+    kmip_linked_list_enqueue(&masks, &mask_1);
+    kmip_linked_list_enqueue(&masks, &mask_2);
+    psm.masks = &masks;
+
+    CreateRequestPayload payload = {0};
+    payload.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    payload.attributes = &attributes;
+    payload.protection_storage_masks = &psm;
+    
+    int result = kmip_encode_create_request_payload(&ctx, &payload);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_create_request_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[200] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0xC0, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0xA8, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, 
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, 
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, 
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct attribute a[3] = {0};
+    for(int i = 0; i < 3; i++)
+    {
+        kmip_init_attribute(&a[i]);
+    }
+    
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    a[0].value = &algorithm;
+    
+    int32 length = 128;
+    a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    a[1].value = &length;
+    
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    a[2].value = &mask;
+    
+    struct template_attribute ta = {0};
+    ta.attributes = a;
+    ta.attribute_count = ARRAY_LENGTH(a);
+    
+    struct create_request_payload expected = {0};
+    expected.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    expected.template_attribute = &ta;
+    
+    struct create_request_payload observed = {0};
+    
+    int result = kmip_decode_create_request_payload(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_create_request_payload(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_create_request_payload(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_create_request_payload_kmip_2_0(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Request Payload
+    *      Object Type - Symmetric Key
+    *      Attributes
+    *          Cryptographic Algorithm - AES
+    *          Cryptographic Length - 128
+    *          Cryptographic Usage Mask - Encrypt | Decrypt
+    *      Protection Storage Masks
+    *          Protection Storage Mask - Software | On System
+    *          Protection Storage Mask - Off System | Off Premises
+    */
+    uint8 encoding[120] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x70, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x25, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x5F, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x5E, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+    
+    Attribute a[3] = {0};
+    for(int i = 0; i < 3; i++)
+    {
+        kmip_init_attribute(&a[i]);
+    }
+    
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    a[0].value = &algorithm;
+    
+    int32 length = 128;
+    a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    a[1].value = &length;
+    
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    a[2].value = &mask;
+    
+    Attributes attributes = {0};
+    LinkedList list = {0};
+    LinkedListItem item_1, item_2, item_3 = {0};
+    item_1.data = &a[0];
+    item_2.data = &a[1];
+    item_3.data = &a[2];
+    kmip_linked_list_enqueue(&list, &item_1);
+    kmip_linked_list_enqueue(&list, &item_2);
+    kmip_linked_list_enqueue(&list, &item_3);
+    attributes.attribute_list = &list;
+
+    ProtectionStorageMasks psm = {0};
+    LinkedList masks = {0};
+    LinkedListItem mask_1, mask_2 = {0};
+    int32 m1 = KMIP_PROTECT_SOFTWARE | KMIP_PROTECT_ON_SYSTEM;
+    int32 m2 = KMIP_PROTECT_OFF_SYSTEM | KMIP_PROTECT_OFF_PREMISES;
+    mask_1.data = &m1;
+    mask_2.data = &m2;
+    kmip_linked_list_enqueue(&masks, &mask_1);
+    kmip_linked_list_enqueue(&masks, &mask_2);
+    psm.masks = &masks;
+
+    CreateRequestPayload expected = {0};
+    expected.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    expected.attributes = &attributes;
+    expected.protection_storage_masks = &psm;
+    
+    CreateRequestPayload observed = {0};
+    
+    int result = kmip_decode_create_request_payload(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_create_request_payload(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_create_request_payload(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_create_response_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[72] = {
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x40, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[72] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct create_response_payload crp = {0};
+    crp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    crp.unique_identifier = &uuid;
+    
+    int result = kmip_encode_create_response_payload(&ctx, &crp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_create_response_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[72] = {
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x40, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct create_response_payload expected = {0};
+    expected.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    expected.unique_identifier = &uuid;
+    
+    struct create_response_payload observed = {0};
+    
+    int result = kmip_decode_create_response_payload(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_create_response_payload(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_create_response_payload(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_create_response_payload_with_template_attribute(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[136] = {
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x80, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, 
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, 
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+    };
+    
+    uint8 observed[136] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct attribute a = {0};
+    kmip_init_attribute(&a);
+    
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    a.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    a.value = &algorithm;
+    
+    struct template_attribute ta = {0};
+    ta.attributes = &a;
+    ta.attribute_count = 1;
+    
+    struct create_response_payload crp = {0};
+    crp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    crp.unique_identifier = &uuid;
+    crp.template_attribute = &ta;
+    
+    int result = kmip_encode_create_response_payload(&ctx, &crp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_create_response_payload_with_template_attribute(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[136] = {
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x80, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, 
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, 
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct attribute a = {0};
+    kmip_init_attribute(&a);
+    
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    a.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    a.value = &algorithm;
+    
+    struct template_attribute ta = {0};
+    ta.attributes = &a;
+    ta.attribute_count = 1;
+    
+    struct create_response_payload expected = {0};
+    expected.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    expected.unique_identifier = &uuid;
+    expected.template_attribute = &ta;
+    
+    struct create_response_payload observed = {0};
+    
+    int result = kmip_decode_create_response_payload(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_create_response_payload(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_create_response_payload(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_get_request_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[56] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[56] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    struct get_request_payload grp = {0};
+    grp.unique_identifier = &uuid;
+    
+    int result = kmip_encode_get_request_payload(&ctx, &grp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_get_request_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[56] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    struct get_request_payload expected = {0};
+    expected.unique_identifier = &uuid;
+    
+    struct get_request_payload observed = {0};
+    
+    int result = kmip_decode_get_request_payload(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_get_request_payload(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_get_request_payload(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_get_request_payload_with_format_compression(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[88] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x50, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x37, 0x63, 0x66, 0x35, 0x32, 0x30, 0x39, 0x62, 
+        0x2D, 0x36, 0x66, 0x66, 0x36, 0x2D, 0x34, 0x34, 
+        0x32, 0x36, 0x2D, 0x38, 0x39, 0x39, 0x65, 0x2D, 
+        0x32, 0x32, 0x62, 0x30, 0x36, 0x37, 0x38, 0x35, 
+        0x39, 0x33, 0x37, 0x32, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x41, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[88] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "7cf5209b-6ff6-4426-899e-22b067859372";
+    uuid.size = 36;
+    
+    struct get_request_payload grp = {0};
+    grp.unique_identifier = &uuid;
+    grp.key_format_type = KMIP_KEYFORMAT_PKCS1;
+    grp.key_compression_type = KMIP_KEYCOMP_EC_PUB_UNCOMPRESSED;
+    
+    int result = kmip_encode_get_request_payload(&ctx, &grp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_get_request_payload_with_wrapping_spec(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[160] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x98, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x62, 0x66, 0x66, 0x37, 0x33, 0x34, 0x37, 0x62, 
+        0x2D, 0x33, 0x61, 0x33, 0x39, 0x2D, 0x34, 0x63, 
+        0x63, 0x62, 0x2D, 0x38, 0x32, 0x33, 0x34, 0x2D, 
+        0x62, 0x61, 0x32, 0x35, 0x36, 0x30, 0x63, 0x61, 
+        0x31, 0x35, 0x39, 0x38, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x47, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, 
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[160] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string wrapping_uuid = {0};
+    wrapping_uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    wrapping_uuid.size = 36;
+    struct text_string uuid = {0};
+    uuid.value = "bff7347b-3a39-4ccb-8234-ba2560ca1598";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &wrapping_uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    struct key_wrapping_specification kws = {0};
+    kws.wrapping_method = KMIP_WRAP_ENCRYPT;
+    kws.encryption_key_info = &eki;
+    
+    struct get_request_payload grp = {0};
+    grp.unique_identifier = &uuid;
+    grp.key_wrapping_spec = &kws;
+    
+    int result = kmip_encode_get_request_payload(&ctx, &grp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_get_response_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[176] = {
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[176] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    uint8 value[24] = {
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8
+    };
+    struct byte_string v = {0};
+    v.value = value;
+    v.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &v;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &kv;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES;
+    kb.cryptographic_length = 168;
+    
+    struct symmetric_key key = {0};
+    key.key_block = &kb;
+    
+    struct get_response_payload grp = {0};
+    grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    grp.unique_identifier = &uuid;
+    grp.object = &key;
+    
+    int result = kmip_encode_get_response_payload(&ctx, &grp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_get_response_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[176] = {
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    uint8 value[24] = {
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8
+    };
+    struct byte_string v = {0};
+    v.value = value;
+    v.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &v;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &kv;
+    kb.key_value_type = KMIP_TYPE_STRUCTURE;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES;
+    kb.cryptographic_length = 168;
+    
+    struct symmetric_key key = {0};
+    key.key_block = &kb;
+    
+    struct get_response_payload expected = {0};
+    expected.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    expected.unique_identifier = &uuid;
+    expected.object = &key;
+    
+    struct get_response_payload observed = {0};
+    
+    int result = kmip_decode_get_response_payload(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_get_response_payload(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_get_response_payload(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_destroy_request_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[56] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[56] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct destroy_request_payload drp = {0};
+    drp.unique_identifier = &uuid;
+    
+    int result = kmip_encode_destroy_request_payload(&ctx, &drp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_destroy_request_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[56] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct destroy_request_payload expected = {0};
+    expected.unique_identifier = &uuid;
+    
+    struct destroy_request_payload observed = {0};
+    
+    int result = kmip_decode_destroy_request_payload(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_destroy_request_payload(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_destroy_request_payload(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_destroy_response_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[56] = {
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[56] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct destroy_response_payload drp = {0};
+    drp.unique_identifier = &uuid;
+    
+    int result = kmip_encode_destroy_response_payload(&ctx, &drp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_destroy_response_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[56] = {
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct destroy_response_payload expected = {0};
+    expected.unique_identifier = &uuid;
+    
+    struct destroy_response_payload observed = {0};
+    
+    int result = kmip_decode_destroy_response_payload(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_destroy_response_payload(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_destroy_response_payload(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_username_password_credential(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[48] = {
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x28, 
+        0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x04, 
+        0x46, 0x72, 0x65, 0x64, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x09, 
+        0x70, 0x61, 0x73, 0x73, 0x77, 0x6F, 0x72, 0x64, 
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[48] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string username = {0};
+    username.value = "Fred";
+    username.size = 4;
+    struct text_string password = {0};
+    password.value = "password1";
+    password.size = 9;
+    
+    struct username_password_credential upc = {0};
+    upc.username = &username;
+    upc.password = &password;
+    
+    int result = kmip_encode_username_password_credential(&ctx, &upc);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_username_password_credential(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[48] = {
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x28, 
+        0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x04, 
+        0x46, 0x72, 0x65, 0x64, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x09, 
+        0x70, 0x61, 0x73, 0x73, 0x77, 0x6F, 0x72, 0x64, 
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string username = {0};
+    username.value = "Fred";
+    username.size = 4;
+    struct text_string password = {0};
+    password.value = "password1";
+    password.size = 9;
+    
+    struct username_password_credential expected = {0};
+    expected.username = &username;
+    expected.password = &password;
+    
+    struct username_password_credential observed = {0};
+    
+    int result = kmip_decode_username_password_credential(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_username_password_credential(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_username_password_credential(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_credential_username_password_credential(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[64] = {
+        0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, 
+        0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, 
+        0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00
+    };
+    
+    uint8 observed[64] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string username = {0};
+    username.value = "Barney";
+    username.size = 6;
+    struct text_string password = {0};
+    password.value = "secret2";
+    password.size = 7;
+    
+    struct username_password_credential upc = {0};
+    upc.username = &username;
+    upc.password = &password;
+    
+    struct credential c = {0};
+    c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD;
+    c.credential_value = &upc;
+    
+    int result = kmip_encode_credential(&ctx, &c);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_credential_username_password_credential(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[64] = {
+        0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, 
+        0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, 
+        0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string username = {0};
+    username.value = "Barney";
+    username.size = 6;
+    struct text_string password = {0};
+    password.value = "secret2";
+    password.size = 7;
+    
+    struct username_password_credential upc = {0};
+    upc.username = &username;
+    upc.password = &password;
+    
+    struct credential expected = {0};
+    expected.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD;
+    expected.credential_value = &upc;
+
+    struct credential observed = {0};
+    
+    int result = kmip_decode_credential(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_credential(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_credential(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_authentication_username_password_credential(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[80] = {
+        0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x40, 
+        0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x28, 
+        0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x04, 
+        0x46, 0x72, 0x65, 0x64, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x09, 
+        0x70, 0x61, 0x73, 0x73, 0x77, 0x6F, 0x72, 0x64, 
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[80] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string username = {0};
+    username.value = "Fred";
+    username.size = 4;
+    struct text_string password = {0};
+    password.value = "password1";
+    password.size = 9;
+    
+    struct username_password_credential upc = {0};
+    upc.username = &username;
+    upc.password = &password;
+    
+    struct credential c = {0};
+    c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD;
+    c.credential_value = &upc;
+    
+    struct authentication a = {0};
+    a.credential = &c;
+    
+    int result = kmip_encode_authentication(&ctx, &a);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_authentication_username_password_credential(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[80] = {
+        0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x40, 
+        0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x28, 
+        0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x04, 
+        0x46, 0x72, 0x65, 0x64, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x09, 
+        0x70, 0x61, 0x73, 0x73, 0x77, 0x6F, 0x72, 0x64, 
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string username = {0};
+    username.value = "Fred";
+    username.size = 4;
+    struct text_string password = {0};
+    password.value = "password1";
+    password.size = 9;
+    
+    struct username_password_credential upc = {0};
+    upc.username = &username;
+    upc.password = &password;
+    
+    struct credential c = {0};
+    c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD;
+    c.credential_value = &upc;
+    
+    struct authentication expected = {0};
+    expected.credential = &c;
+    
+    struct authentication observed = {0};
+    
+    int result = kmip_decode_authentication(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_authentication(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_authentication(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_request_header(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[168] = {
+        0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0xA0, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x40, 
+        0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, 
+        0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, 
+        0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00, 
+        0x42, 0x00, 0x0E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x10, 0x06, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[168] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    struct text_string username = {0};
+    username.value = "Barney";
+    username.size = 6;
+    struct text_string password = {0};
+    password.value = "secret2";
+    password.size = 7;
+    
+    struct username_password_credential upc = {0};
+    upc.username = &username;
+    upc.password = &password;
+    
+    struct credential c = {0};
+    c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD;
+    c.credential_value = &upc;
+    
+    struct authentication a = {0};
+    a.credential = &c;
+    
+    struct request_header rh = {0};
+    kmip_init_request_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.authentication = &a;
+    rh.batch_error_continuation_option = KMIP_BATCH_CONTINUE;
+    rh.batch_order_option = KMIP_TRUE;
+    rh.batch_count = 2;
+    
+    int result = kmip_encode_request_header(&ctx, &rh);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_request_header(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[168] = {
+        0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0xA0, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x40, 
+        0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, 
+        0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, 
+        0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00, 
+        0x42, 0x00, 0x0E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x10, 0x06, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    struct text_string username = {0};
+    username.value = "Barney";
+    username.size = 6;
+    struct text_string password = {0};
+    password.value = "secret2";
+    password.size = 7;
+    
+    struct username_password_credential upc = {0};
+    upc.username = &username;
+    upc.password = &password;
+    
+    struct credential c = {0};
+    c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD;
+    c.credential_value = &upc;
+    
+    struct authentication a = {0};
+    a.credential = &c;
+    
+    struct request_header expected = {0};
+    kmip_init_request_header(&expected);
+    
+    expected.protocol_version = &pv;
+    expected.authentication = &a;
+    expected.batch_error_continuation_option = KMIP_BATCH_CONTINUE;
+    expected.batch_order_option = KMIP_TRUE;
+    expected.batch_count = 2;
+    
+    struct request_header observed = {0};
+    kmip_init_request_header(&observed);
+    
+    int result = kmip_decode_request_header(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_request_header(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_request_header(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_response_header(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[80] = {
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[80] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    struct response_header rh = {0};
+    kmip_init_response_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.time_stamp = 1335514341;
+    rh.batch_count = 1;
+    
+    int result = kmip_encode_response_header(&ctx, &rh);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_response_header(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[80] = {
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    struct response_header expected = {0};
+    kmip_init_response_header(&expected);
+    
+    expected.protocol_version = &pv;
+    expected.time_stamp = 1335514341;
+    expected.batch_count = 1;
+    
+    struct response_header observed = {0};
+    kmip_init_response_header(&observed);
+    
+    int result = kmip_decode_response_header(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_response_header(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_response_header(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_request_batch_item_get_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[80] = {
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[80] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    struct get_request_payload grp = {0};
+    grp.unique_identifier = &uuid;
+    
+    struct request_batch_item rbi = {0};
+    kmip_init_request_batch_item(&rbi);
+    rbi.operation = KMIP_OP_GET;
+    rbi.request_payload = &grp;
+    
+    int result = kmip_encode_request_batch_item(&ctx, &rbi);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_request_batch_item_get_payload_kmip_2_0(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Batch Item
+    *      Operation - Get
+    *      Ephemeral - False
+    *      Request Payload
+    *          Unique Identifier - 49a1ca88-6bea-4fb2-b450-7e58802c3038
+    */
+    uint8 expected[96] = {
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x58,
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x54, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38,
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66,
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D,
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63,
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+
+    uint8 observed[96] = {0};
+    KMIP ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    TextString uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+
+    GetRequestPayload grp = {0};
+    grp.unique_identifier = &uuid;
+
+    RequestBatchItem rbi = {0};
+    kmip_init_request_batch_item(&rbi);
+    rbi.operation = KMIP_OP_GET;
+    rbi.ephemeral = KMIP_FALSE;
+    rbi.request_payload = &grp;
+
+    int result = kmip_encode_request_batch_item(&ctx, &rbi);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_request_batch_item_get_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[80] = {
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    struct get_request_payload grp = {0};
+    grp.unique_identifier = &uuid;
+    
+    struct request_batch_item expected = {0};
+    kmip_init_request_batch_item(&expected);
+    expected.operation = KMIP_OP_GET;
+    expected.request_payload = &grp;
+    
+    struct request_batch_item observed = {0};
+    kmip_init_request_batch_item(&observed);
+    
+    int result = kmip_decode_request_batch_item(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_request_batch_item(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_request_batch_item(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_request_batch_item_get_payload_kmip_2_0(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Batch Item
+    *      Operation - Get
+    *      Ephemeral - False
+    *      Request Payload
+    *          Unique Identifier - 49a1ca88-6bea-4fb2-b450-7e58802c3038
+    */
+    uint8 encoding[96] = {
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x58,
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x54, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30,
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38,
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66,
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D,
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63,
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    TextString uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+
+    GetRequestPayload grp = {0};
+    grp.unique_identifier = &uuid;
+
+    RequestBatchItem expected = {0};
+    kmip_init_request_batch_item(&expected);
+    expected.operation = KMIP_OP_GET;
+    expected.ephemeral = KMIP_FALSE;
+    expected.request_payload = &grp;
+
+    RequestBatchItem observed = {0};
+    kmip_init_request_batch_item(&observed);
+
+    int result = kmip_decode_request_batch_item(&ctx, &observed);
+    int comparison = kmip_compare_request_batch_item(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_request_batch_item(1, &expected);
+        kmip_print_request_batch_item(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_request_batch_item(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_response_batch_item_get_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[216] = {
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD0, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[216] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    uint8 value[24] = {
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8
+    };
+    
+    struct byte_string v = {0};
+    v.value = value;
+    v.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &v;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &kv;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES;
+    kb.cryptographic_length = 168;
+    
+    struct symmetric_key key = {0};
+    key.key_block = &kb;
+    
+    struct get_response_payload grp = {0};
+    grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    grp.unique_identifier = &uuid;
+    grp.object = &key;
+    
+    struct response_batch_item rbi = {0};
+    rbi.operation = KMIP_OP_GET;
+    rbi.result_status = KMIP_STATUS_SUCCESS;
+    rbi.response_payload = &grp;
+    
+    int result = kmip_encode_response_batch_item(&ctx, &rbi);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_response_batch_item_get_payload(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[216] = {
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD0, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    uint8 value[24] = {
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8
+    };
+    
+    struct byte_string v = {0};
+    v.value = value;
+    v.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &v;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &kv;
+    kb.key_value_type = KMIP_TYPE_STRUCTURE;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES;
+    kb.cryptographic_length = 168;
+    
+    struct symmetric_key key = {0};
+    key.key_block = &kb;
+    
+    struct get_response_payload grp = {0};
+    grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    grp.unique_identifier = &uuid;
+    grp.object = &key;
+    
+    struct response_batch_item expected = {0};
+    expected.operation = KMIP_OP_GET;
+    expected.result_status = KMIP_STATUS_SUCCESS;
+    expected.response_payload = &grp;
+    
+    struct response_batch_item observed = {0};
+    
+    int result = kmip_decode_response_batch_item(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_response_batch_item(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_response_batch_item(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_request_message_get(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[152] = {
+        0x42, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x90, 
+        0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[152] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    struct request_header rh = {0};
+    kmip_init_request_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.batch_count = 1;
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    struct get_request_payload grp = {0};
+    grp.unique_identifier = &uuid;
+    
+    struct request_batch_item rbi = {0};
+    kmip_init_request_batch_item(&rbi);
+    rbi.operation = KMIP_OP_GET;
+    rbi.request_payload = &grp;
+    
+    struct request_message rm = {0};
+    rm.request_header = &rh;
+    rm.batch_items = &rbi;
+    rm.batch_count = 1;
+    
+    int result = kmip_encode_request_message(&ctx, &rm);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_request_message_get(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[152] = {
+        0x42, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x90, 
+        0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    struct request_header rh = {0};
+    kmip_init_request_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.batch_count = 1;
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    struct get_request_payload grp = {0};
+    grp.unique_identifier = &uuid;
+    
+    struct request_batch_item rbi = {0};
+    kmip_init_request_batch_item(&rbi);
+    rbi.operation = KMIP_OP_GET;
+    rbi.request_payload = &grp;
+    
+    struct request_message expected = {0};
+    expected.request_header = &rh;
+    expected.batch_items = &rbi;
+    expected.batch_count = 1;
+    
+    struct request_message observed = {0};
+    
+    int result = kmip_decode_request_message(&ctx, &observed);
+    int comparison = kmip_compare_request_message(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_request_message(&expected);
+        kmip_print_request_message(&observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_request_message(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_response_message_get(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[304] = {
+        0x42, 0x00, 0x7B, 0x01, 0x00, 0x00, 0x01, 0x28, 
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE7, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD0, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[304] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    struct response_header rh = {0};
+    kmip_init_response_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.time_stamp = 1335514343;
+    rh.batch_count = 1;
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    uint8 value[24] = {
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8
+    };
+    
+    struct byte_string v = {0};
+    v.value = value;
+    v.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &v;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &kv;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES;
+    kb.cryptographic_length = 168;
+    
+    struct symmetric_key key = {0};
+    key.key_block = &kb;
+    
+    struct get_response_payload grp = {0};
+    grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    grp.unique_identifier = &uuid;
+    grp.object = &key;
+    
+    struct response_batch_item rbi = {0};
+    rbi.operation = KMIP_OP_GET;
+    rbi.result_status = KMIP_STATUS_SUCCESS;
+    rbi.response_payload = &grp;
+    
+    struct response_message rm = {0};
+    rm.response_header = &rh;
+    rm.batch_items = &rbi;
+    rm.batch_count = 1;
+    
+    int result = kmip_encode_response_message(&ctx, &rm);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_response_message_get(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[304] = {
+        0x42, 0x00, 0x7B, 0x01, 0x00, 0x00, 0x01, 0x28, 
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE7, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD0, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    struct response_header rh = {0};
+    kmip_init_response_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.time_stamp = 1335514343;
+    rh.batch_count = 1;
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    uint8 value[24] = {
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8
+    };
+    
+    struct byte_string v = {0};
+    v.value = value;
+    v.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &v;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &kv;
+    kb.key_value_type = KMIP_TYPE_STRUCTURE;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES;
+    kb.cryptographic_length = 168;
+    
+    struct symmetric_key key = {0};
+    key.key_block = &kb;
+    
+    struct get_response_payload grp = {0};
+    grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    grp.unique_identifier = &uuid;
+    grp.object = &key;
+    
+    struct response_batch_item rbi = {0};
+    rbi.operation = KMIP_OP_GET;
+    rbi.result_status = KMIP_STATUS_SUCCESS;
+    rbi.response_payload = &grp;
+    
+    struct response_message expected = {0};
+    expected.response_header = &rh;
+    expected.batch_items = &rbi;
+    expected.batch_count = 1;
+    
+    struct response_message observed = {0};
+    
+    int result = kmip_decode_response_message(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_response_message(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_response_message(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_attributes(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Attributes
+    *      Cryptographic Algorithm - AES
+    *      Cryptographic Length - 128
+    */
+    uint8 expected[40] = {
+        0x42, 0x01, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[40] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    LinkedList attribute_list = {0};
+
+    LinkedListItem item_1 = {0};
+    Attribute attr_1 = {0};
+    kmip_init_attribute(&attr_1);
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    attr_1.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    attr_1.value = &algorithm;
+    item_1.data = &attr_1;
+
+    LinkedListItem item_2 = {0};
+    Attribute attr_2 = {0};
+    kmip_init_attribute(&attr_2);
+    int32 length = 128;
+    attr_2.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    attr_2.value = &length;
+    item_2.data = &attr_2;
+
+    kmip_linked_list_enqueue(&attribute_list, &item_1);
+    kmip_linked_list_enqueue(&attribute_list, &item_2);
+
+    Attributes attributes = {0};
+    attributes.attribute_list = &attribute_list;
+
+    int result = kmip_encode_attributes(&ctx, &attributes);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_encode_attributes_with_invalid_kmip_version(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 observed[40] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4);
+
+    Attributes attributes = {0};
+
+    int result = kmip_encode_attributes(&ctx, &attributes);
+    kmip_destroy(&ctx);
+
+    result = report_result(tracker, result, KMIP_INVALID_FOR_VERSION, __func__);
+    return(result);
+}
+
+int
+test_encode_attribute_v2_unique_identifier(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Unique Identifier - fb4b5b9c-6188-4c63-8142-fe9c328129fc
+    */
+    uint8 expected[48] = {
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63,
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63,
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D,
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31,
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+
+    uint8 observed[48] = {0};
+    KMIP ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    Attribute attribute = {0};
+    kmip_init_attribute(&attribute);
+    TextString unique_identifier = {0};
+    unique_identifier.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    unique_identifier.size = 36;
+    attribute.type = KMIP_ATTR_UNIQUE_IDENTIFIER;
+    attribute.value = &unique_identifier;
+
+    int result = kmip_encode_attribute_v2(&ctx, &attribute);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_encode_attribute_v2_name(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Name
+    *      Value - Template1
+    *      Type - Uninterpreted Text String
+    */
+    uint8 expected[48] = {
+        0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28,
+        0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09,
+        0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65,
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+
+    uint8 observed[48] = {0};
+    KMIP ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    Attribute attribute = {0};
+    kmip_init_attribute(&attribute);
+    TextString name_value = {0};
+    name_value.value = "Template1";
+    name_value.size = 9;
+    Name name = {0};
+    name.value = &name_value;
+    name.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+
+    attribute.type = KMIP_ATTR_NAME;
+    attribute.value = &name;
+
+    int result = kmip_encode_attribute_v2(&ctx, &attribute);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_encode_attribute_v2_object_type(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Object Type - Symmetric Key
+    */
+    uint8 expected[16] = {
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
+    };
+
+    uint8 observed[16] = {0};
+    KMIP ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    Attribute attribute = {0};
+    kmip_init_attribute(&attribute);
+    enum object_type object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    attribute.type = KMIP_ATTR_OBJECT_TYPE;
+    attribute.value = &object_type;
+
+    int result = kmip_encode_attribute_v2(&ctx, &attribute);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_encode_attribute_v2_cryptographic_algorithm(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Cryptographic Algorithm - AES
+    */
+    uint8 expected[16] = {
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
+    };
+
+    uint8 observed[16] = {0};
+    KMIP ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    Attribute attribute = {0};
+    kmip_init_attribute(&attribute);
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    attribute.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    attribute.value = &algorithm;
+
+    int result = kmip_encode_attribute_v2(&ctx, &attribute);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_encode_attribute_v2_cryptographic_length(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Cryptographic Length - 128
+    */
+    uint8 expected[16] = {
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+
+    uint8 observed[16] = {0};
+    KMIP ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    Attribute attribute = {0};
+    kmip_init_attribute(&attribute);
+    int32 length = 128;
+    attribute.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    attribute.value = &length;
+
+    int result = kmip_encode_attribute_v2(&ctx, &attribute);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_encode_attribute_v2_cryptographic_usage_mask(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Cryptographic Usage Mask - Encrypt | Decrypt
+    */
+    uint8 expected[16] = {
+        0x42, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00
+    };
+
+    uint8 observed[16] = {0};
+    KMIP ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    Attribute attribute = {0};
+    kmip_init_attribute(&attribute);
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    attribute.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    attribute.value = &mask;
+
+    int result = kmip_encode_attribute_v2(&ctx, &attribute);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_encode_attribute_v2_state(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  State - Active
+    */
+    uint8 expected[16] = {
+        0x42, 0x00, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
+    };
+
+    uint8 observed[16] = {0};
+    KMIP ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    Attribute attribute = {0};
+    kmip_init_attribute(&attribute);
+    enum state state = KMIP_STATE_ACTIVE;
+    attribute.type = KMIP_ATTR_STATE;
+    attribute.value = &state;
+
+    int result = kmip_encode_attribute_v2(&ctx, &attribute);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_encode_attribute_v2_unsupported_attribute(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[16] = {0};
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    Attribute attribute = {0};
+    attribute.type = -1;
+    int result = kmip_encode_attribute_v2(&ctx, &attribute);
+    if(result != KMIP_ERROR_ATTR_UNSUPPORTED)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_destroy(&ctx);
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_decode_attributes(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Attributes
+    *      Cryptographic Algorithm - AES
+    *      Cryptographic Length - 128
+    */
+    uint8 encoding[40] = {
+        0x42, 0x01, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    LinkedList attribute_list = {0};
+
+    LinkedListItem item_1 = {0};
+    Attribute attr_1 = {0};
+    kmip_init_attribute(&attr_1);
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    attr_1.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    attr_1.value = &algorithm;
+    item_1.data = &attr_1;
+
+    LinkedListItem item_2 = {0};
+    Attribute attr_2 = {0};
+    kmip_init_attribute(&attr_2);
+    int32 length = 128;
+    attr_2.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    attr_2.value = &length;
+    item_2.data = &attr_2;
+
+    kmip_linked_list_enqueue(&attribute_list, &item_1);
+    kmip_linked_list_enqueue(&attribute_list, &item_2);
+
+    Attributes expected = {0};
+    expected.attribute_list = &attribute_list;
+
+    Attributes observed = {0};
+    int result = kmip_decode_attributes(&ctx, &observed);
+    int comparison = kmip_compare_attributes(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_attributes(1, &expected);
+        kmip_print_attributes(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_attributes(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_decode_attributes_with_invalid_kmip_version(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[] = {0};
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_4);
+
+    Attributes observed = {0};
+    int result = kmip_decode_attributes(&ctx, &observed);
+
+    kmip_free_attributes(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    result = report_result(tracker, result, KMIP_INVALID_FOR_VERSION, __func__);
+    return(result);
+}
+
+int
+test_decode_attribute_v2_unique_identifier(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Unique Identifier - fb4b5b9c-6188-4c63-8142-fe9c328129fc
+    */
+    uint8 encoding[48] = {
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24,
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63,
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63,
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D,
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31,
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    Attribute expected = {0};
+    kmip_init_attribute(&expected);
+    TextString unique_identifier = {0};
+    unique_identifier.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    unique_identifier.size = 36;
+    expected.type = KMIP_ATTR_UNIQUE_IDENTIFIER;
+    expected.value = &unique_identifier;
+
+    Attribute observed = {0};
+    int result = kmip_decode_attribute_v2(&ctx, &observed);
+    int comparison = kmip_compare_attribute(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_decode_attribute_v2_name(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Name
+    *      Value - Template1
+    *      Type - Uninterpreted Text String
+    */
+    uint8 encoding[48] = {
+        0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28,
+        0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09,
+        0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65,
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    Attribute expected = {0};
+    kmip_init_attribute(&expected);
+    TextString name_value = {0};
+    name_value.value = "Template1";
+    name_value.size = 9;
+    Name name = {0};
+    name.value = &name_value;
+    name.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+
+    expected.type = KMIP_ATTR_NAME;
+    expected.value = &name;
+
+    Attribute observed = {0};
+    int result = kmip_decode_attribute_v2(&ctx, &observed);
+    int comparison = kmip_compare_attribute(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_decode_attribute_v2_object_type(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Object Type - Symmetric Key
+    */
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    Attribute expected = {0};
+    kmip_init_attribute(&expected);
+    enum object_type object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    expected.type = KMIP_ATTR_OBJECT_TYPE;
+    expected.value = &object_type;
+
+    Attribute observed = {0};
+    int result = kmip_decode_attribute_v2(&ctx, &observed);
+    int comparison = kmip_compare_attribute(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_decode_attribute_v2_cryptographic_algorithm(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Cryptographic Algorithm - AES
+    */
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    Attribute expected = {0};
+    kmip_init_attribute(&expected);
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    expected.value = &algorithm;
+
+    Attribute observed = {0};
+    int result = kmip_decode_attribute_v2(&ctx, &observed);
+    int comparison = kmip_compare_attribute(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_decode_attribute_v2_cryptographic_length(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Cryptographic Length - 128
+    */
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    Attribute expected = {0};
+    kmip_init_attribute(&expected);
+    int32 length = 128;
+    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    expected.value = &length;
+
+    Attribute observed = {0};
+    int result = kmip_decode_attribute_v2(&ctx, &observed);
+    int comparison = kmip_compare_attribute(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_decode_attribute_v2_cryptographic_usage_mask(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  Cryptographic Usage Mask - Encrypt | Decrypt
+    */
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    Attribute expected = {0};
+    kmip_init_attribute(&expected);
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    expected.value = &mask;
+
+    Attribute observed = {0};
+    int result = kmip_decode_attribute_v2(&ctx, &observed);
+    int comparison = kmip_compare_attribute(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_decode_attribute_v2_state(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following value:
+    *  State - Active
+    */
+    uint8 encoding[16] = {
+        0x42, 0x00, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    Attribute expected = {0};
+    kmip_init_attribute(&expected);
+    enum state state = KMIP_STATE_ACTIVE;
+    expected.type = KMIP_ATTR_STATE;
+    expected.value = &state;
+
+    Attribute observed = {0};
+    int result = kmip_decode_attribute_v2(&ctx, &observed);
+    int comparison = kmip_compare_attribute(&expected, &observed);
+    if(!comparison)
+    {
+        kmip_print_attribute(1, &expected);
+        kmip_print_attribute(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    return(result);
+}
+
+int
+test_decode_attribute_v2_unsupported_attribute(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[3] = {0x42, 0x00, 0x00};
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    Attribute observed = {0};
+    int result = kmip_decode_attribute_v2(&ctx, &observed);
+    if(result != KMIP_ERROR_ATTR_UNSUPPORTED)
+    {
+        TEST_FAILED(tracker, __func__, __LINE__);
+    }
+
+    kmip_free_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+
+    TEST_PASSED(tracker, __func__);
+}
+
+int
+test_encode_template_attribute(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[288] = {
+        0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x01, 0x18, 
+        0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28, 
+        0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09, 
+        0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, 
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, 
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, 
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x04, 
+        0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x04, 
+        0x4B, 0x65, 0x79, 0x31, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[288] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct text_string v = {0};
+    v.value = "Template1";
+    v.size = 9;
+    
+    struct name n = {0};
+    n.value = &v;
+    n.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+    
+    struct attribute a[4] = {0};
+    for(int i = 0; i < 4; i++)
+    {
+        kmip_init_attribute(&a[i]);
+    }
+    
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    a[0].value = &algorithm;
+    
+    int32 length = 128;
+    a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    a[1].value = &length;
+    
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    a[2].value = &mask;
+    
+    struct text_string value = {0};
+    value.value = "Key1";
+    value.size = 4;
+    
+    struct name name = {0};
+    name.value = &value;
+    name.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+    a[3].type = KMIP_ATTR_NAME;
+    a[3].value = &name;
+    
+    struct template_attribute ta = {0};
+    ta.names = &n;
+    ta.name_count = 1;
+    ta.attributes = a;
+    ta.attribute_count = ARRAY_LENGTH(a);
+    
+    int result = kmip_encode_template_attribute(&ctx, &ta);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_template_attribute(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[288] = {
+        0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x01, 0x18, 
+        0x42, 0x00, 0x53, 0x01, 0x00, 0x00, 0x00, 0x28, 
+        0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x09, 
+        0x54, 0x65, 0x6D, 0x70, 0x6C, 0x61, 0x74, 0x65, 
+        0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, 
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, 
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, 
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x04, 
+        0x4E, 0x61, 0x6D, 0x65, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x55, 0x07, 0x00, 0x00, 0x00, 0x04, 
+        0x4B, 0x65, 0x79, 0x31, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x54, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
+    
+    struct text_string v = {0};
+    v.value = "Template1";
+    v.size = 9;
+    
+    struct name n = {0};
+    n.value = &v;
+    n.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+    
+    struct attribute a[4] = {0};
+    for(int i = 0; i < 4; i++)
+    {
+        kmip_init_attribute(&a[i]);
+    }
+    
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    a[0].value = &algorithm;
+    
+    int32 length = 128;
+    a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    a[1].value = &length;
+    
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    a[2].value = &mask;
+    
+    struct text_string value = {0};
+    value.value = "Key1";
+    value.size = 4;
+    
+    struct name name = {0};
+    name.value = &value;
+    name.type = KMIP_NAME_UNINTERPRETED_TEXT_STRING;
+    a[3].type = KMIP_ATTR_NAME;
+    a[3].value = &name;
+    
+    struct template_attribute expected = {0};
+    expected.names = &n;
+    expected.name_count = 1;
+    expected.attributes = a;
+    expected.attribute_count = ARRAY_LENGTH(a);
+    struct template_attribute observed = {0};
+    
+    int result = kmip_decode_template_attribute(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_template_attribute(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_template_attribute(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+/*
+The following tests cover features added in KMIP 1.1.
+*/
+
+int
+test_encode_device_credential(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[144] = {
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x88, 
+        0x42, 0x00, 0xB0, 0x07, 0x00, 0x00, 0x00, 0x0C, 
+        0x73, 0x65, 0x72, 0x4E, 0x75, 0x6D, 0x31, 0x32, 
+        0x33, 0x34, 0x35, 0x36, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x06, 
+        0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x00, 0x00, 
+        0x42, 0x00, 0xA2, 0x07, 0x00, 0x00, 0x00, 0x09, 
+        0x64, 0x65, 0x76, 0x49, 0x44, 0x32, 0x32, 0x33, 
+        0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xAB, 0x07, 0x00, 0x00, 0x00, 0x09, 
+        0x6E, 0x65, 0x74, 0x49, 0x44, 0x39, 0x30, 0x30, 
+        0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xA9, 0x07, 0x00, 0x00, 0x00, 0x0A, 
+        0x6D, 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x49, 
+        0x44, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xAA, 0x07, 0x00, 0x00, 0x00, 0x0A, 
+        0x6D, 0x65, 0x64, 0x69, 0x61, 0x49, 0x44, 0x33, 
+        0x31, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[144] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1);
+    
+    struct text_string dsn = {0};
+    dsn.value = "serNum123456";
+    dsn.size = 12;
+    
+    struct text_string p = {0};
+    p.value = "secret";
+    p.size = 6;
+    
+    struct text_string di = {0};
+    di.value = "devID2233";
+    di.size = 9;
+    
+    struct text_string ni = {0};
+    ni.value = "netID9000";
+    ni.size = 9;
+    
+    struct text_string mac = {0};
+    mac.value = "machineID1";
+    mac.size = 10;
+    
+    struct text_string med = {0};
+    med.value = "mediaID313";
+    med.size = 10;
+    
+    struct device_credential dc = {0};
+    dc.device_serial_number = &dsn;
+    dc.password = &p;
+    dc.device_identifier = &di;
+    dc.network_identifier = &ni;
+    dc.machine_identifier = &mac;
+    dc.media_identifier = &med;
+    
+    int result = kmip_encode_device_credential(&ctx, &dc);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_device_credential(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[144] = {
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x88, 
+        0x42, 0x00, 0xB0, 0x07, 0x00, 0x00, 0x00, 0x0C, 
+        0x73, 0x65, 0x72, 0x4E, 0x75, 0x6D, 0x31, 0x32, 
+        0x33, 0x34, 0x35, 0x36, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x06, 
+        0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x00, 0x00, 
+        0x42, 0x00, 0xA2, 0x07, 0x00, 0x00, 0x00, 0x09, 
+        0x64, 0x65, 0x76, 0x49, 0x44, 0x32, 0x32, 0x33, 
+        0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xAB, 0x07, 0x00, 0x00, 0x00, 0x09, 
+        0x6E, 0x65, 0x74, 0x49, 0x44, 0x39, 0x30, 0x30, 
+        0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xA9, 0x07, 0x00, 0x00, 0x00, 0x0A, 
+        0x6D, 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x49, 
+        0x44, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xAA, 0x07, 0x00, 0x00, 0x00, 0x0A, 
+        0x6D, 0x65, 0x64, 0x69, 0x61, 0x49, 0x44, 0x33, 
+        0x31, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_1);
+    
+    struct text_string dsn = {0};
+    dsn.value = "serNum123456";
+    dsn.size = 12;
+    
+    struct text_string p = {0};
+    p.value = "secret";
+    p.size = 6;
+    
+    struct text_string di = {0};
+    di.value = "devID2233";
+    di.size = 9;
+    
+    struct text_string ni = {0};
+    ni.value = "netID9000";
+    ni.size = 9;
+    
+    struct text_string mac = {0};
+    mac.value = "machineID1";
+    mac.size = 10;
+    
+    struct text_string med = {0};
+    med.value = "mediaID313";
+    med.size = 10;
+    
+    struct device_credential expected = {0};
+    expected.device_serial_number = &dsn;
+    expected.password = &p;
+    expected.device_identifier = &di;
+    expected.network_identifier = &ni;
+    expected.machine_identifier = &mac;
+    expected.media_identifier = &med;
+    
+    struct device_credential observed = {0};
+    
+    int result = kmip_decode_device_credential(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_device_credential(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_device_credential(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_key_wrapping_data_with_encoding_option(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[120] = {
+        0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x70, 
+        0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35,
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10,
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xA3, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[120] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    struct key_wrapping_data kwd = {0};
+    kwd.wrapping_method = KMIP_WRAP_ENCRYPT;
+    kwd.encryption_key_info = &eki;
+    kwd.encoding_option = KMIP_ENCODE_NO_ENCODING;
+    
+    int result = kmip_encode_key_wrapping_data(&ctx, &kwd);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_key_wrapping_data_with_encoding_option(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[120] = {
+        0x42, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x70, 
+        0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35,
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10,
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xA3, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_1);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    kmip_init_cryptographic_parameters(&cp);
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    struct key_wrapping_data expected = {0};
+    expected.wrapping_method = KMIP_WRAP_ENCRYPT;
+    expected.encryption_key_info = &eki;
+    expected.encoding_option = KMIP_ENCODE_NO_ENCODING;
+    
+    struct key_wrapping_data observed = {0};
+    
+    int result = kmip_decode_key_wrapping_data(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_key_wrapping_data(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_key_wrapping_data(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_key_wrapping_specification_with_encoding_option(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[120] = {
+        0x42, 0x00, 0x47, 0x01, 0x00, 0x00, 0x00, 0x70, 
+        0x42, 0x00, 0x9E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x36, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x31, 0x30, 0x30, 0x31, 0x38, 0x32, 0x64, 0x35, 
+        0x2D, 0x37, 0x32, 0x62, 0x38, 0x2D, 0x34, 0x37, 
+        0x61, 0x61, 0x2D, 0x38, 0x33, 0x38, 0x33, 0x2D, 
+        0x34, 0x64, 0x39, 0x37, 0x64, 0x35, 0x31, 0x32, 
+        0x65, 0x39, 0x38, 0x61, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xA3, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[120] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1);
+    
+    struct text_string uuid = {0};
+    uuid.value = "100182d5-72b8-47aa-8383-4d97d512e98a";
+    uuid.size = 36;
+    
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_NIST_KEY_WRAP;
+    
+    struct encryption_key_information eki = {0};
+    eki.unique_identifier = &uuid;
+    eki.cryptographic_parameters = &cp;
+    
+    struct key_wrapping_specification kws = {0};
+    kws.wrapping_method = KMIP_WRAP_ENCRYPT;
+    kws.encryption_key_info = &eki;
+    kws.encoding_option = KMIP_ENCODE_NO_ENCODING;
+    
+    int result = kmip_encode_key_wrapping_specification(&ctx, &kws);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+/*
+The following tests cover features added in KMIP 1.2.
+*/
+
+int
+test_encode_nonce(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[40] = {
+        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
+        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00
+    };
+    
+    uint8 observed[40] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2);
+    
+    uint8 id[4] = {0x01, 0x02, 0x03, 0x04};
+    struct byte_string ni = {0};
+    ni.value = id;
+    ni.size = ARRAY_LENGTH(id);
+    
+    uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    struct byte_string nv = {0};
+    nv.value = value;
+    nv.size = ARRAY_LENGTH(value);
+    
+    struct nonce n = {0};
+    n.nonce_id = &ni;
+    n.nonce_value = &nv;
+    
+    int result = kmip_encode_nonce(&ctx, &n);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_nonce(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[40] = {
+        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
+        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_2);
+    
+    uint8 id[4] = {0x01, 0x02, 0x03, 0x04};
+    struct byte_string ni = {0};
+    ni.value = id;
+    ni.size = ARRAY_LENGTH(id);
+    
+    uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    struct byte_string nv = {0};
+    nv.value = value;
+    nv.size = ARRAY_LENGTH(value);
+    
+    struct nonce expected = {0};
+    expected.nonce_id = &ni;
+    expected.nonce_value = &nv;
+    
+    struct nonce observed = {0};
+    
+    int result = kmip_decode_nonce(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_nonce(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_nonce(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_attestation_credential(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[128] = {
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x70,
+        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
+        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCB, 0x08, 0x00, 0x00, 0x00, 0x10,
+        0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44,
+        0x66, 0x66, 0x66, 0x66, 0x88, 0x88, 0x88, 0x88,
+        0x42, 0x00, 0xCC, 0x08, 0x00, 0x00, 0x00, 0x14,
+        0x11, 0x11, 0x11, 0x11, 0x33, 0x33, 0x33, 0x33,
+        0x55, 0x55, 0x55, 0x55, 0x77, 0x77, 0x77, 0x77,
+        0x99, 0x99, 0x99, 0x99, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[128] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2);
+    
+    uint8 nonce_id[4] = {0x01, 0x02, 0x03, 0x04};
+    struct byte_string ni = {0};
+    ni.value = nonce_id;
+    ni.size = ARRAY_LENGTH(nonce_id);
+    
+    uint8 nonce_value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    struct byte_string nv = {0};
+    nv.value = nonce_value;
+    nv.size = ARRAY_LENGTH(nonce_value);
+    
+    struct nonce n = {0};
+    n.nonce_id = &ni;
+    n.nonce_value = &nv;
+    
+    uint8 measurement[16] = {
+        0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44,
+        0x66, 0x66, 0x66, 0x66, 0x88, 0x88, 0x88, 0x88
+    };
+    struct byte_string am = {0};
+    am.value = measurement;
+    am.size = ARRAY_LENGTH(measurement);
+    
+    uint8 assertion[20] = {
+        0x11, 0x11, 0x11, 0x11, 0x33, 0x33, 0x33, 0x33,
+        0x55, 0x55, 0x55, 0x55, 0x77, 0x77, 0x77, 0x77,
+        0x99, 0x99, 0x99, 0x99
+    };
+    struct byte_string aa = {0};
+    aa.value = assertion;
+    aa.size = ARRAY_LENGTH(assertion);
+    
+    struct attestation_credential ac = {0};
+    ac.nonce = &n;
+    ac.attestation_type = KMIP_ATTEST_TPM_QUOTE;
+    ac.attestation_measurement = &am;
+    ac.attestation_assertion = &aa;
+    
+    int result = kmip_encode_attestation_credential(&ctx, &ac);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_attestation_credential(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[128] = {
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x70,
+        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
+        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCB, 0x08, 0x00, 0x00, 0x00, 0x10,
+        0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44,
+        0x66, 0x66, 0x66, 0x66, 0x88, 0x88, 0x88, 0x88,
+        0x42, 0x00, 0xCC, 0x08, 0x00, 0x00, 0x00, 0x14,
+        0x11, 0x11, 0x11, 0x11, 0x33, 0x33, 0x33, 0x33,
+        0x55, 0x55, 0x55, 0x55, 0x77, 0x77, 0x77, 0x77,
+        0x99, 0x99, 0x99, 0x99, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_2);
+    
+    uint8 nonce_id[4] = {0x01, 0x02, 0x03, 0x04};
+    struct byte_string ni = {0};
+    ni.value = nonce_id;
+    ni.size = ARRAY_LENGTH(nonce_id);
+    
+    uint8 nonce_value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    struct byte_string nv = {0};
+    nv.value = nonce_value;
+    nv.size = ARRAY_LENGTH(nonce_value);
+    
+    struct nonce n = {0};
+    n.nonce_id = &ni;
+    n.nonce_value = &nv;
+    
+    uint8 measurement[16] = {
+        0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44,
+        0x66, 0x66, 0x66, 0x66, 0x88, 0x88, 0x88, 0x88
+    };
+    struct byte_string am = {0};
+    am.value = measurement;
+    am.size = ARRAY_LENGTH(measurement);
+    
+    uint8 assertion[20] = {
+        0x11, 0x11, 0x11, 0x11, 0x33, 0x33, 0x33, 0x33,
+        0x55, 0x55, 0x55, 0x55, 0x77, 0x77, 0x77, 0x77,
+        0x99, 0x99, 0x99, 0x99
+    };
+    struct byte_string aa = {0};
+    aa.value = assertion;
+    aa.size = ARRAY_LENGTH(assertion);
+    
+    struct attestation_credential expected = {0};
+    expected.nonce = &n;
+    expected.attestation_type = KMIP_ATTEST_TPM_QUOTE;
+    expected.attestation_measurement = &am;
+    expected.attestation_assertion = &aa;
+    
+    struct attestation_credential observed = {0};
+    
+    int result = kmip_decode_attestation_credential(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_attestation_credential(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_attestation_credential(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_request_header_with_attestation_details(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[216] = {
+        0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0xD0, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0xD3, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x40, 
+        0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, 
+        0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, 
+        0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00, 
+        0x42, 0x00, 0x0E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x10, 0x06, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[216] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    struct text_string username = {0};
+    username.value = "Barney";
+    username.size = 6;
+    struct text_string password = {0};
+    password.value = "secret2";
+    password.size = 7;
+    
+    struct username_password_credential upc = {0};
+    upc.username = &username;
+    upc.password = &password;
+    
+    struct credential c = {0};
+    c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD;
+    c.credential_value = &upc;
+    
+    struct authentication a = {0};
+    a.credential = &c;
+    
+    enum attestation_type types[2] = {
+        KMIP_ATTEST_TPM_QUOTE, 
+        KMIP_ATTEST_SAML_ASSERTION
+    };
+    
+    struct request_header rh = {0};
+    kmip_init_request_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.attestation_capable_indicator = KMIP_TRUE;
+    rh.attestation_types = types;
+    rh.attestation_type_count = ARRAY_LENGTH(types);
+    rh.authentication = &a;
+    rh.batch_error_continuation_option = KMIP_BATCH_CONTINUE;
+    rh.batch_order_option = KMIP_TRUE;
+    rh.batch_count = 2;
+    
+    int result = kmip_encode_request_header(&ctx, &rh);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_response_header_with_attestation_details(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[152] = {
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x90, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5,
+        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
+        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[152] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    uint8 id[4] = {0x01, 0x02, 0x03, 0x04};
+    struct byte_string ni = {0};
+    ni.value = id;
+    ni.size = ARRAY_LENGTH(id);
+    
+    uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    struct byte_string nv = {0};
+    nv.value = value;
+    nv.size = ARRAY_LENGTH(value);
+    
+    struct nonce n = {0};
+    n.nonce_id = &ni;
+    n.nonce_value = &nv;
+    
+    enum attestation_type types[2] = {
+        KMIP_ATTEST_TPM_QUOTE,
+        KMIP_ATTEST_SAML_ASSERTION
+    };
+    
+    struct response_header rh = {0};
+    kmip_init_response_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.time_stamp = 1335514341;
+    rh.nonce = &n;
+    rh.attestation_types = types;
+    rh.attestation_type_count = ARRAY_LENGTH(types);
+    rh.batch_count = 1;
+    
+    int result = kmip_encode_response_header(&ctx, &rh);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_response_header_with_attestation_details(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[152] = {
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x90, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5,
+        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
+        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_2);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    uint8 id[4] = {0x01, 0x02, 0x03, 0x04};
+    struct byte_string ni = {0};
+    ni.value = id;
+    ni.size = ARRAY_LENGTH(id);
+    
+    uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    struct byte_string nv = {0};
+    nv.value = value;
+    nv.size = ARRAY_LENGTH(value);
+    
+    struct nonce n = {0};
+    n.nonce_id = &ni;
+    n.nonce_value = &nv;
+    
+    enum attestation_type types[2] = {
+        KMIP_ATTEST_TPM_QUOTE,
+        KMIP_ATTEST_SAML_ASSERTION
+    };
+    
+    struct response_header expected = {0};
+    kmip_init_response_header(&expected);
+    
+    expected.protocol_version = &pv;
+    expected.time_stamp = 1335514341;
+    expected.nonce = &n;
+    expected.attestation_types = types;
+    expected.attestation_type_count = ARRAY_LENGTH(types);
+    expected.batch_count = 1;
+    
+    struct response_header observed = {0};
+    kmip_init_response_header(&observed);
+    
+    int result = kmip_decode_response_header(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_response_header(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_response_header(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_cryptographic_parameters_with_digital_signature_fields(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[216] = {
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0xD0,
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xAE, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC5, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+        0x42, 0x00, 0xCD, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCE, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCF, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD2, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD0, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD1, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[216] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2);
+    
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_CBC;
+    cp.padding_method = KMIP_PAD_PKCS5;
+    cp.hashing_algorithm = KMIP_HASH_SHA1;
+    cp.key_role_type = KMIP_ROLE_KEK;
+    
+    cp.digital_signature_algorithm = KMIP_DIGITAL_SHA256_WITH_RSA;
+    cp.cryptographic_algorithm = KMIP_CRYPTOALG_RSA;
+    cp.random_iv = KMIP_TRUE;
+    cp.iv_length = 128;
+    cp.tag_length = 64;
+    cp.fixed_field_length = 64;
+    cp.invocation_field_length = 64;
+    cp.counter_length = 256;
+    cp.initial_counter_value = 0;
+    
+    int result = kmip_encode_cryptographic_parameters(&ctx, &cp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_cryptographic_parameters_with_digital_signature_fields(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[216] = {
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0xD0,
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xAE, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00 ,0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC5, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+        0x42, 0x00, 0xCD, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCE, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCF, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD2, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD0, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD1, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_2);
+    
+    struct cryptographic_parameters expected = {0};
+    kmip_init_cryptographic_parameters(&expected);
+    expected.block_cipher_mode = KMIP_BLOCK_CBC;
+    expected.padding_method = KMIP_PAD_PKCS5;
+    expected.hashing_algorithm = KMIP_HASH_SHA1;
+    expected.key_role_type = KMIP_ROLE_KEK;
+    
+    expected.digital_signature_algorithm = KMIP_DIGITAL_SHA256_WITH_RSA;
+    expected.cryptographic_algorithm = KMIP_CRYPTOALG_RSA;
+    expected.random_iv = KMIP_TRUE;
+    expected.iv_length = 128;
+    expected.tag_length = 64;
+    expected.fixed_field_length = 64;
+    expected.invocation_field_length = 64;
+    expected.counter_length = 256;
+    expected.initial_counter_value = 0;
+    
+    struct cryptographic_parameters observed = {0};
+    kmip_init_cryptographic_parameters(&observed);
+    
+    int result = kmip_decode_cryptographic_parameters(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_cryptographic_parameters(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_cryptographic_parameters(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+/*
+The following tests cover features added in KMIP 1.4.
+*/
+
+int
+test_encode_cryptographic_parameters_with_mask_fields(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[312] = {
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x01, 0x30,
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xAE, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC5, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+        0x42, 0x00, 0xCD, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCE, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCF, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD2, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD0, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD1, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x01, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x02, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x03, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8,
+        0x42, 0x01, 0x04, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[312] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4);
+    
+    uint8 value[24] = {
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8
+    };
+    struct byte_string ps = {0};
+    ps.value = value;
+    ps.size = ARRAY_LENGTH(value);
+    
+    struct cryptographic_parameters cp = {0};
+    cp.block_cipher_mode = KMIP_BLOCK_CBC;
+    cp.padding_method = KMIP_PAD_PKCS5;
+    cp.hashing_algorithm = KMIP_HASH_SHA1;
+    cp.key_role_type = KMIP_ROLE_KEK;
+    
+    cp.digital_signature_algorithm = KMIP_DIGITAL_SHA256_WITH_RSA;
+    cp.cryptographic_algorithm = KMIP_CRYPTOALG_RSA;
+    cp.random_iv = KMIP_TRUE;
+    cp.iv_length = 128;
+    cp.tag_length = 64;
+    cp.fixed_field_length = 64;
+    cp.invocation_field_length = 64;
+    cp.counter_length = 256;
+    cp.initial_counter_value = 0;
+    
+    cp.salt_length = 32;
+    cp.mask_generator = KMIP_MASKGEN_MGF1;
+    cp.mask_generator_hashing_algorithm = KMIP_HASH_SHA256;
+    cp.p_source = &ps;
+    cp.trailer_field = 1;
+    
+    int result = kmip_encode_cryptographic_parameters(&ctx, &cp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_cryptographic_parameters_with_mask_fields(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[312] = {
+        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x01, 0x30,
+        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x83, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xAE, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC5, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+        0x42, 0x00, 0xCD, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCE, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCF, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD2, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD0, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xD1, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x01, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x02, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x03, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8,
+        0x42, 0x01, 0x04, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_4);
+    
+    uint8 value[24] = {
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8
+    };
+    struct byte_string ps = {0};
+    ps.value = value;
+    ps.size = ARRAY_LENGTH(value);
+    
+    struct cryptographic_parameters expected = {0};
+    kmip_init_cryptographic_parameters(&expected);
+    
+    expected.block_cipher_mode = KMIP_BLOCK_CBC;
+    expected.padding_method = KMIP_PAD_PKCS5;
+    expected.hashing_algorithm = KMIP_HASH_SHA1;
+    expected.key_role_type = KMIP_ROLE_KEK;
+    
+    expected.digital_signature_algorithm = KMIP_DIGITAL_SHA256_WITH_RSA;
+    expected.cryptographic_algorithm = KMIP_CRYPTOALG_RSA;
+    expected.random_iv = KMIP_TRUE;
+    expected.iv_length = 128;
+    expected.tag_length = 64;
+    expected.fixed_field_length = 64;
+    expected.invocation_field_length = 64;
+    expected.counter_length = 256;
+    expected.initial_counter_value = 0;
+    
+    expected.salt_length = 32;
+    expected.mask_generator = KMIP_MASKGEN_MGF1;
+    expected.mask_generator_hashing_algorithm = KMIP_HASH_SHA256;
+    expected.p_source = &ps;
+    expected.trailer_field = 1;
+    
+    struct cryptographic_parameters observed = {0};
+    kmip_init_cryptographic_parameters(&observed);
+    
+    int result = kmip_decode_cryptographic_parameters(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_cryptographic_parameters(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_cryptographic_parameters(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_get_request_payload_with_wrap_type(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[104] = {
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x37, 0x63, 0x66, 0x35, 0x32, 0x30, 0x39, 0x62, 
+        0x2D, 0x36, 0x66, 0x66, 0x36, 0x2D, 0x34, 0x34, 
+        0x32, 0x36, 0x2D, 0x38, 0x39, 0x39, 0x65, 0x2D, 
+        0x32, 0x32, 0x62, 0x30, 0x36, 0x37, 0x38, 0x35, 
+        0x39, 0x33, 0x37, 0x32, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xF8, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x41, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[104] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4);
+    
+    struct text_string uuid = {0};
+    uuid.value = "7cf5209b-6ff6-4426-899e-22b067859372";
+    uuid.size = 36;
+    
+    struct get_request_payload grp = {0};
+    grp.unique_identifier = &uuid;
+    grp.key_format_type = KMIP_KEYFORMAT_PKCS1;
+    grp.key_compression_type = KMIP_KEYCOMP_EC_PUB_UNCOMPRESSED;
+    
+    grp.key_wrap_type = KMIP_WRAPTYPE_NOT_WRAPPED;
+    
+    int result = kmip_encode_get_request_payload(&ctx, &grp);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_request_header_with_correlation_values(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[280] = {
+        0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x01, 0x10, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x50, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00, 0x08,
+        0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x31,
+        0x42, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x08,
+        0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x31,
+        0x42, 0x00, 0x07, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+        0x42, 0x00, 0xD3, 0x06, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0C, 0x01, 0x00, 0x00, 0x00, 0x40, 
+        0x42, 0x00, 0x23, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x24, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x25, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x99, 0x07, 0x00, 0x00, 0x00, 0x06, 
+        0x42, 0x61, 0x72, 0x6E, 0x65, 0x79, 0x00, 0x00, 
+        0x42, 0x00, 0xA1, 0x07, 0x00, 0x00, 0x00, 0x07, 
+        0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x32, 0x00, 
+        0x42, 0x00, 0x0E, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x10, 0x06, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[280] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    struct text_string username = {0};
+    username.value = "Barney";
+    username.size = 6;
+    struct text_string password = {0};
+    password.value = "secret2";
+    password.size = 7;
+    
+    struct username_password_credential upc = {0};
+    upc.username = &username;
+    upc.password = &password;
+    
+    struct credential c = {0};
+    c.credential_type = KMIP_CRED_USERNAME_AND_PASSWORD;
+    c.credential_value = &upc;
+    
+    struct authentication a = {0};
+    a.credential = &c;
+    
+    enum attestation_type types[2] = {
+        KMIP_ATTEST_TPM_QUOTE, 
+        KMIP_ATTEST_SAML_ASSERTION
+    };
+    
+    struct text_string ccv = {0};
+    ccv.value = "client 1";
+    ccv.size = 8;
+    
+    struct text_string scv = {0};
+    scv.value = "server 1";
+    scv.size = 8;
+    
+    struct request_header rh = {0};
+    kmip_init_request_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.maximum_response_size = 4096;
+    rh.asynchronous_indicator = KMIP_TRUE;
+    rh.attestation_capable_indicator = KMIP_TRUE;
+    rh.attestation_types = types;
+    rh.attestation_type_count = ARRAY_LENGTH(types);
+    rh.authentication = &a;
+    rh.batch_error_continuation_option = KMIP_BATCH_CONTINUE;
+    rh.batch_order_option = KMIP_TRUE;
+    rh.batch_count = 2;
+    
+    rh.client_correlation_value = &ccv;
+    rh.server_correlation_value = &scv;
+    
+    int result = kmip_encode_request_header(&ctx, &rh);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_response_header_with_correlation_values(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[184] = {
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0xB0, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5,
+        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
+        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00, 0x08,
+        0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x31,
+        0x42, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x08,
+        0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x31, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[184] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    uint8 id[4] = {0x01, 0x02, 0x03, 0x04};
+    struct byte_string ni = {0};
+    ni.value = id;
+    ni.size = ARRAY_LENGTH(id);
+    
+    uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    struct byte_string nv = {0};
+    nv.value = value;
+    nv.size = ARRAY_LENGTH(value);
+    
+    struct nonce n = {0};
+    n.nonce_id = &ni;
+    n.nonce_value = &nv;
+    
+    enum attestation_type types[2] = {
+        KMIP_ATTEST_TPM_QUOTE,
+        KMIP_ATTEST_SAML_ASSERTION
+    };
+    
+    struct text_string ccv = {0};
+    ccv.value = "client 1";
+    ccv.size = 8;
+    
+    struct text_string scv = {0};
+    scv.value = "server 1";
+    scv.size = 8;
+    
+    struct response_header rh = {0};
+    kmip_init_response_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.time_stamp = 1335514341;
+    rh.nonce = &n;
+    rh.attestation_types = types;
+    rh.attestation_type_count = ARRAY_LENGTH(types);
+    rh.batch_count = 1;
+    
+    rh.client_correlation_value = &ccv;
+    rh.server_correlation_value = &scv;
+    
+    int result = kmip_encode_response_header(&ctx, &rh);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_response_header_with_correlation_values(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 encoding[184] = {
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0xB0, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5,
+        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
+        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00, 0x08,
+        0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x31,
+        0x42, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x08,
+        0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x31, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    struct kmip ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_4);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 0;
+    
+    uint8 id[4] = {0x01, 0x02, 0x03, 0x04};
+    struct byte_string ni = {0};
+    ni.value = id;
+    ni.size = ARRAY_LENGTH(id);
+    
+    uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    struct byte_string nv = {0};
+    nv.value = value;
+    nv.size = ARRAY_LENGTH(value);
+    
+    struct nonce n = {0};
+    n.nonce_id = &ni;
+    n.nonce_value = &nv;
+    
+    enum attestation_type types[2] = {
+        KMIP_ATTEST_TPM_QUOTE,
+        KMIP_ATTEST_SAML_ASSERTION
+    };
+    
+    struct text_string ccv = {0};
+    ccv.value = "client 1";
+    ccv.size = 8;
+    
+    struct text_string scv = {0};
+    scv.value = "server 1";
+    scv.size = 8;
+    
+    struct response_header expected = {0};
+    kmip_init_response_header(&expected);
+    
+    expected.protocol_version = &pv;
+    expected.time_stamp = 1335514341;
+    expected.nonce = &n;
+    expected.attestation_types = types;
+    expected.attestation_type_count = ARRAY_LENGTH(types);
+    expected.batch_count = 1;
+    
+    expected.client_correlation_value = &ccv;
+    expected.server_correlation_value = &scv;
+    
+    struct response_header observed = {0};
+    kmip_init_response_header(&observed);
+    
+    int result = kmip_decode_response_header(&ctx, &observed);
+    result = report_decoding_test_result(
+        tracker,
+        &ctx,
+        kmip_compare_response_header(&expected, &observed),
+        result,
+        __func__);
+    kmip_free_response_header(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_encode_response_header_kmip_2_0(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Response Header
+    *      Protocol Version
+    *          Protocol Version Major - 2
+    *          Protocol Version Minor - 0
+    *      Time Stamp - 1335514341
+    *      Nonce
+    *          Nonce ID - 0x01020304
+    *          Nonce Value - 0xFFFFFFFFFFFF
+    *      Server Hashed Password - 301EC144E9C6C4F64C29C01C3E11839C97D6E7D2BC0C5DBC68377B679AE51D4D
+    *      Attestation Type - TPM Quote
+    *      Attestation Type - SAML Assertion
+    *      Client Correlation Value - client 1
+    *      Server Correlation Value - server 1
+    *      Batch Count - 1
+    */
+    uint8 expected[224] = {
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0xD8,
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5,
+        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
+        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+        0x42, 0x01, 0x55, 0x08, 0x00, 0x00, 0x00, 0x20,
+        0x30, 0x1E, 0xC1, 0x44, 0xE9, 0xC6, 0xC4, 0xF6,
+        0x4C, 0x29, 0xC0, 0x1C, 0x3E, 0x11, 0x83, 0x9C,
+        0x97, 0xD6, 0xE7, 0xD2, 0xBC, 0x0C, 0x5D, 0xBC,
+        0x68, 0x37, 0x7B, 0x67, 0x9A, 0xE5, 0x1D, 0x4D,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00, 0x08,
+        0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x31,
+        0x42, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x08,
+        0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x31,
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+
+    uint8 observed[224] = {0};
+    KMIP ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);
+
+    ProtocolVersion pv = {0};
+    pv.major = 2;
+    pv.minor = 0;
+
+    uint8 id[4] = {0x01, 0x02, 0x03, 0x04};
+    ByteString ni = {0};
+    ni.value = id;
+    ni.size = ARRAY_LENGTH(id);
+
+    uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    ByteString nv = {0};
+    nv.value = value;
+    nv.size = ARRAY_LENGTH(value);
+
+    Nonce n = {0};
+    n.nonce_id = &ni;
+    n.nonce_value = &nv;
+
+    uint8 hash[32] = {
+        0x30, 0x1E, 0xC1, 0x44, 0xE9, 0xC6, 0xC4, 0xF6,
+        0x4C, 0x29, 0xC0, 0x1C, 0x3E, 0x11, 0x83, 0x9C,
+        0x97, 0xD6, 0xE7, 0xD2, 0xBC, 0x0C, 0x5D, 0xBC,
+        0x68, 0x37, 0x7B, 0x67, 0x9A, 0xE5, 0x1D, 0x4D
+    };
+    ByteString shp = {0};
+    shp.value = hash;
+    shp.size = ARRAY_LENGTH(hash);
+
+    enum attestation_type types[2] = {
+        KMIP_ATTEST_TPM_QUOTE,
+        KMIP_ATTEST_SAML_ASSERTION
+    };
+
+    TextString ccv = {0};
+    ccv.value = "client 1";
+    ccv.size = 8;
+
+    TextString scv = {0};
+    scv.value = "server 1";
+    scv.size = 8;
+
+    ResponseHeader rh = {0};
+    kmip_init_response_header(&rh);
+
+    rh.protocol_version = &pv;
+    rh.time_stamp = 1335514341;
+    rh.nonce = &n;
+    rh.server_hashed_password = &shp;
+    rh.attestation_types = types;
+    rh.attestation_type_count = ARRAY_LENGTH(types);
+    rh.batch_count = 1;
+
+    rh.client_correlation_value = &ccv;
+    rh.server_correlation_value = &scv;
+
+    int result = kmip_encode_response_header(&ctx, &rh);
+    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);
+
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_decode_response_header_kmip_2_0(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* This encoding matches the following set of values:
+    *  Response Header
+    *      Protocol Version
+    *          Protocol Version Major - 2
+    *          Protocol Version Minor - 0
+    *      Time Stamp - 1335514341
+    *      Nonce
+    *          Nonce ID - 0x01020304
+    *          Nonce Value - 0xFFFFFFFFFFFF
+    *      Server Hashed Password - 301EC144E9C6C4F64C29C01C3E11839C97D6E7D2BC0C5DBC68377B679AE51D4D
+    *      Attestation Type - TPM Quote
+    *      Attestation Type - SAML Assertion
+    *      Client Correlation Value - client 1
+    *      Server Correlation Value - server 1
+    *      Batch Count - 1
+    */
+    uint8 encoding[224] = {
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0xD8,
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5,
+        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
+        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
+        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+        0x42, 0x01, 0x55, 0x08, 0x00, 0x00, 0x00, 0x20,
+        0x30, 0x1E, 0xC1, 0x44, 0xE9, 0xC6, 0xC4, 0xF6,
+        0x4C, 0x29, 0xC0, 0x1C, 0x3E, 0x11, 0x83, 0x9C,
+        0x97, 0xD6, 0xE7, 0xD2, 0xBC, 0x0C, 0x5D, 0xBC,
+        0x68, 0x37, 0x7B, 0x67, 0x9A, 0xE5, 0x1D, 0x4D,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0xC7, 0x05, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00, 0x08,
+        0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x31,
+        0x42, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x08,
+        0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x31,
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
+    };
+
+    KMIP ctx = {0};
+    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);
+
+    ProtocolVersion pv = {0};
+    pv.major = 2;
+    pv.minor = 0;
+
+    uint8 id[4] = {0x01, 0x02, 0x03, 0x04};
+    ByteString ni = {0};
+    ni.value = id;
+    ni.size = ARRAY_LENGTH(id);
+
+    uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    ByteString nv = {0};
+    nv.value = value;
+    nv.size = ARRAY_LENGTH(value);
+
+    Nonce n = {0};
+    n.nonce_id = &ni;
+    n.nonce_value = &nv;
+
+    uint8 hash[32] = {
+        0x30, 0x1E, 0xC1, 0x44, 0xE9, 0xC6, 0xC4, 0xF6,
+        0x4C, 0x29, 0xC0, 0x1C, 0x3E, 0x11, 0x83, 0x9C,
+        0x97, 0xD6, 0xE7, 0xD2, 0xBC, 0x0C, 0x5D, 0xBC,
+        0x68, 0x37, 0x7B, 0x67, 0x9A, 0xE5, 0x1D, 0x4D
+    };
+    ByteString shp = {0};
+    shp.value = hash;
+    shp.size = ARRAY_LENGTH(hash);
+
+    enum attestation_type types[2] = {
+        KMIP_ATTEST_TPM_QUOTE,
+        KMIP_ATTEST_SAML_ASSERTION
+    };
+
+    TextString ccv = {0};
+    ccv.value = "client 1";
+    ccv.size = 8;
+
+    TextString scv = {0};
+    scv.value = "server 1";
+    scv.size = 8;
+
+    ResponseHeader expected = {0};
+    kmip_init_response_header(&expected);
+
+    expected.protocol_version = &pv;
+    expected.time_stamp = 1335514341;
+    expected.nonce = &n;
+    expected.server_hashed_password = &shp;
+    expected.attestation_types = types;
+    expected.attestation_type_count = ARRAY_LENGTH(types);
+    expected.batch_count = 1;
+
+    expected.client_correlation_value = &ccv;
+    expected.server_correlation_value = &scv;
+
+    ResponseHeader observed = {0};
+    kmip_init_response_header(&observed);
+
+    int result = kmip_decode_response_header(&ctx, &observed);
+    int comparison = kmip_compare_response_header(&expected, &observed);
+    if(!comparison)
+    {
+        /* TODO (ph) Reorder these with printing result so that objects are
+                     below function name.
+        */
+        kmip_print_response_header(1, &expected);
+        kmip_print_response_header(1, &observed);
+    }
+    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);
+
+    kmip_free_response_header(&ctx, &observed);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+/*
+The following tests are taken verbatim from the KMIP 1.1 Test Cases
+documentation, available here:
+
+http://docs.oasis-open.org/kmip/testcases/v1.1/kmip-testcases-v1.1.html
+*/
+
+int
+test_kmip_1_1_test_suite_3_1_1_0_a(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* KMIP 1.1 Test Suite - Test 3.1.1.0a */
+    uint8 expected[296] = {
+        0x42, 0x00, 0x78, 0x01, 0x00, 0x00, 0x01, 0x20, 
+        0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD8, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0xC0, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0xA8, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x17, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x41, 0x6C, 
+        0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x00, 
+        0x42, 0x00, 0x0B, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x14, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x4C, 0x65, 
+        0x6E, 0x67, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x18, 
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6F, 0x67, 0x72, 
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x55, 0x73, 
+        0x61, 0x67, 0x65, 0x20, 0x4D, 0x61, 0x73, 0x6B, 
+        0x42, 0x00, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[296] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1);
+    
+    /* TODO (ph) If protocol version omitted, pull from context? */
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 1;
+    
+    struct request_header rh = {0};
+    kmip_init_request_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.batch_count = 1;
+    
+    struct attribute a[3] = {0};
+    for(int i = 0; i < 3; i++)
+    {
+        kmip_init_attribute(&a[i]);
+    }
+    
+    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
+    a[0].type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
+    a[0].value = &algorithm;
+    
+    int32 length = 128;
+    a[1].type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
+    a[1].value = &length;
+    
+    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
+    a[2].type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
+    a[2].value = &mask;
+    
+    struct template_attribute ta = {0};
+    ta.attributes = a;
+    ta.attribute_count = ARRAY_LENGTH(a);
+    
+    struct create_request_payload crp = {0};
+    crp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    crp.template_attribute = &ta;
+    
+    struct request_batch_item rbi = {0};
+    kmip_init_request_batch_item(&rbi);
+    rbi.operation = KMIP_OP_CREATE;
+    rbi.request_payload = &crp;
+    
+    struct request_message rm = {0};
+    rm.request_header = &rh;
+    rm.batch_items = &rbi;
+    rm.batch_count = 1;
+    
+    int result = kmip_encode_request_message(&ctx, &rm);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_kmip_1_1_test_suite_3_1_1_0_b(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* KMIP 1.1 Test Suite - Test 3.1.1.0b */
+    uint8 expected[200] = {
+        0x42, 0x00, 0x7B, 0x01, 0x00, 0x00, 0x00, 0xC0, 
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x68, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x40, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[200] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 1;
+    
+    struct response_header rh = {0};
+    kmip_init_response_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.time_stamp = 1335514341;
+    rh.batch_count = 1;
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct create_response_payload crp = {0};
+    crp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    crp.unique_identifier = &uuid;
+    
+    struct response_batch_item rbi = {0};
+    rbi.operation = KMIP_OP_CREATE;
+    rbi.result_status = KMIP_STATUS_SUCCESS;
+    rbi.response_payload = &crp;
+    
+    struct response_message rm = {0};
+    rm.response_header = &rh;
+    rm.batch_items = &rbi;
+    rm.batch_count = 1;
+    
+    int result = kmip_encode_response_message(&ctx, &rm);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_kmip_1_1_test_suite_3_1_1_1_a(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* KMIP 1.1 Test Suite - Test 3.1.1.1a */
+    uint8 expected[152] = {
+        0x42, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x90, 
+        0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[152] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 1;
+    
+    struct request_header rh = {0};
+    kmip_init_request_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.batch_count = 1;
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct destroy_request_payload drp = {0};
+    drp.unique_identifier = &uuid;
+    
+    struct request_batch_item rbi = {0};
+    kmip_init_request_batch_item(&rbi);
+    rbi.operation = KMIP_OP_DESTROY;
+    rbi.request_payload = &drp;
+    
+    struct request_message rm = {0};
+    rm.request_header = &rh;
+    rm.batch_items = &rbi;
+    rm.batch_count = 1;
+    
+    int result = kmip_encode_request_message(&ctx, &rm);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_kmip_1_1_test_suite_3_1_1_1_b(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* KMIP 1.1 Test Suite - Test 3.1.1.1b */
+    uint8 expected[184] = {
+        0x42, 0x00, 0x7B, 0x01, 0x00, 0x00, 0x00, 0xB0, 
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE5, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x58, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x66, 0x62, 0x34, 0x62, 0x35, 0x62, 0x39, 0x63, 
+        0x2D, 0x36, 0x31, 0x38, 0x38, 0x2D, 0x34, 0x63, 
+        0x36, 0x33, 0x2D, 0x38, 0x31, 0x34, 0x32, 0x2D, 
+        0x66, 0x65, 0x39, 0x63, 0x33, 0x32, 0x38, 0x31, 
+        0x32, 0x39, 0x66, 0x63, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[184] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 1;
+    
+    struct response_header rh = {0};
+    kmip_init_response_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.time_stamp = 1335514341;
+    rh.batch_count = 1;
+    
+    struct text_string uuid = {0};
+    uuid.value = "fb4b5b9c-6188-4c63-8142-fe9c328129fc";
+    uuid.size = 36;
+    
+    struct destroy_response_payload drp = {0};
+    drp.unique_identifier = &uuid;
+    
+    struct response_batch_item rbi = {0};
+    rbi.operation = KMIP_OP_DESTROY;
+    rbi.result_status = KMIP_STATUS_SUCCESS;
+    rbi.response_payload = &drp;
+    
+    struct response_message rm = {0};
+    rm.response_header = &rh;
+    rm.batch_items = &rbi;
+    rm.batch_count = 1;
+    
+    int result = kmip_encode_response_message(&ctx, &rm);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_kmip_1_1_test_suite_3_1_3_2_a(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    /* KMIP 1.1 Test Suite - Test 3.1.3.2a */
+    uint8 expected[152] = {
+        0x42, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x90, 
+        0x42, 0x00, 0x77, 0x01, 0x00, 0x00, 0x00, 0x38, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x30, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[152] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 1;
+    
+    struct request_header rh = {0};
+    kmip_init_request_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.batch_count = 1;
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    struct get_request_payload grp = {0};
+    grp.unique_identifier = &uuid;
+    
+    struct request_batch_item rbi = {0};
+    kmip_init_request_batch_item(&rbi);
+    rbi.operation = KMIP_OP_GET;
+    rbi.request_payload = &grp;
+    
+    struct request_message rm = {0};
+    rm.request_header = &rh;
+    rm.batch_items = &rbi;
+    rm.batch_count = 1;
+    
+    int result = kmip_encode_request_message(&ctx, &rm);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+int
+test_kmip_1_1_test_suite_3_1_3_2_b(TestTracker *tracker)
+{
+    TRACK_TEST(tracker);
+
+    uint8 expected[304] = {
+        0x42, 0x00, 0x7B, 0x01, 0x00, 0x00, 0x01, 0x28, 
+        0x42, 0x00, 0x7A, 0x01, 0x00, 0x00, 0x00, 0x48, 
+        0x42, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x6A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x92, 0x09, 0x00, 0x00, 0x00, 0x08, 
+        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x54, 0xE7, 
+        0x42, 0x00, 0x0D, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+        0x42, 0x00, 0x0F, 0x01, 0x00, 0x00, 0x00, 0xD0, 
+        0x42, 0x00, 0x5C, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7F, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x7C, 0x01, 0x00, 0x00, 0x00, 0xA8, 
+        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
+        0x34, 0x39, 0x61, 0x31, 0x63, 0x61, 0x38, 0x38, 
+        0x2D, 0x36, 0x62, 0x65, 0x61, 0x2D, 0x34, 0x66, 
+        0x62, 0x32, 0x2D, 0x62, 0x34, 0x35, 0x30, 0x2D, 
+        0x37, 0x65, 0x35, 0x38, 0x38, 0x30, 0x32, 0x63, 
+        0x33, 0x30, 0x33, 0x38, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x8F, 0x01, 0x00, 0x00, 0x00, 0x60, 
+        0x42, 0x00, 0x40, 0x01, 0x00, 0x00, 0x00, 0x58, 
+        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x45, 0x01, 0x00, 0x00, 0x00, 0x20, 
+        0x42, 0x00, 0x43, 0x08, 0x00, 0x00, 0x00, 0x18, 
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8, 
+        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 
+        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04, 
+        0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00
+    };
+    
+    uint8 observed[304] = {0};
+    struct kmip ctx = {0};
+    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_1);
+    
+    struct protocol_version pv = {0};
+    pv.major = 1;
+    pv.minor = 1;
+    
+    struct response_header rh = {0};
+    kmip_init_response_header(&rh);
+    
+    rh.protocol_version = &pv;
+    rh.time_stamp = 1335514343;
+    rh.batch_count = 1;
+    
+    struct text_string uuid = {0};
+    uuid.value = "49a1ca88-6bea-4fb2-b450-7e58802c3038";
+    uuid.size = 36;
+    
+    uint8 value[24] = {
+        0x73, 0x67, 0x57, 0x80, 0x51, 0x01, 0x2A, 0x6D, 
+        0x13, 0x4A, 0x85, 0x5E, 0x25, 0xC8, 0xCD, 0x5E, 
+        0x4C, 0xA1, 0x31, 0x45, 0x57, 0x29, 0xD3, 0xC8
+    };
+
+    struct byte_string v = {0};
+    v.value = value;
+    v.size = ARRAY_LENGTH(value);
+    
+    struct key_value kv = {0};
+    kv.key_material = &v;
+    
+    struct key_block kb = {0};
+    kb.key_format_type = KMIP_KEYFORMAT_RAW;
+    kb.key_value = &kv;
+    kb.cryptographic_algorithm = KMIP_CRYPTOALG_TRIPLE_DES;
+    kb.cryptographic_length = 168;
+    
+    struct symmetric_key key = {0};
+    key.key_block = &kb;
+    
+    struct get_response_payload grp = {0};
+    grp.object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
+    grp.unique_identifier = &uuid;
+    grp.object = &key;
+    
+    struct response_batch_item rbi = {0};
+    rbi.operation = KMIP_OP_GET;
+    rbi.result_status = KMIP_STATUS_SUCCESS;
+    rbi.response_payload = &grp;
+    
+    struct response_message rm = {0};
+    rm.response_header = &rh;
+    rm.batch_items = &rbi;
+    rm.batch_count = 1;
+    
+    int result = kmip_encode_response_message(&ctx, &rm);
+    result = report_encoding_test_result(
+        tracker,
+        &ctx,
+        expected,
+        observed,
+        result,
+        __func__);
+    kmip_destroy(&ctx);
+    return(result);
+}
+
+/* Test Harness */
+
+int
+run_tests(void)
+{
+    TestTracker tracker = {0};
+    
+    printf("Tests\n");
+    printf("=====\n");
+    
+    printf("\nUtility Tests\n");
+    printf("-------------\n");
+    test_linked_list_pop(&tracker);
+    test_linked_list_push(&tracker);
+    test_linked_list_enqueue(&tracker);
+    test_buffer_bytes_left(&tracker);
+    test_peek_tag(&tracker);
+    test_is_attribute_tag(&tracker);
+    test_get_enum_string_index(&tracker);
+    test_check_enum_value_protection_storage_masks(&tracker);
+    test_init_protocol_version(&tracker);
+    test_init_request_batch_item(&tracker);
+    test_deep_copy_int32(&tracker);
+    test_deep_copy_text_string(&tracker);
+    test_deep_copy_name(&tracker);
+    test_deep_copy_attribute(&tracker);
+
+    printf("\nKMIP 1.0 Feature Tests\n");
+    printf("----------------------\n");
+    test_buffer_full_and_resize(&tracker);
+    test_is_tag_next(&tracker);
+    test_get_num_items_next(&tracker);
+    test_get_num_items_next_with_partial_item(&tracker);
+    test_get_num_items_next_with_mismatch_item(&tracker);
+    test_get_num_items_next_with_no_matches(&tracker);
+    test_get_num_items_next_with_non_structures(&tracker);
+    
+    printf("\n");
+    test_decode_int8_be(&tracker);
+    test_decode_int32_be(&tracker);
+    test_decode_int64_be(&tracker);
+    test_decode_integer(&tracker);
+    test_decode_long(&tracker);
+    test_decode_enum(&tracker);
+    test_decode_bool(&tracker);
+    test_decode_text_string(&tracker);
+    test_decode_byte_string(&tracker);
+    test_decode_date_time(&tracker);
+    test_decode_interval(&tracker);
+    test_decode_name(&tracker);
+    test_decode_attribute_unique_identifier(&tracker);
+    test_decode_attribute_name(&tracker);
+    test_decode_attribute_object_type(&tracker);
+    test_decode_attribute_cryptographic_algorithm(&tracker);
+    test_decode_attribute_cryptographic_length(&tracker);
+    test_decode_attribute_operation_policy_name(&tracker);
+    test_decode_attribute_cryptographic_usage_mask(&tracker);
+    test_decode_attribute_state(&tracker);
+    test_decode_template_attribute(&tracker);
+    test_decode_protocol_version(&tracker);
+    test_decode_key_material_byte_string(&tracker);
+    test_decode_key_material_transparent_symmetric_key(&tracker);
+    test_decode_key_value(&tracker);
+    test_decode_key_value_with_attributes(&tracker);
+    test_decode_cryptographic_parameters(&tracker);
+    test_decode_encryption_key_information(&tracker);
+    test_decode_mac_signature_key_information(&tracker);
+    test_decode_key_wrapping_data(&tracker);
+    test_decode_key_block_key_value_byte_string(&tracker);
+    test_decode_key_block_key_value_structure(&tracker);
+    test_decode_symmetric_key(&tracker);
+    test_decode_public_key(&tracker);
+    test_decode_private_key(&tracker);
+    test_decode_key_wrapping_specification(&tracker);
+    test_decode_create_request_payload(&tracker);
+    test_decode_create_response_payload(&tracker);
+    test_decode_create_response_payload_with_template_attribute(&tracker);
+    test_decode_get_request_payload(&tracker);
+    test_decode_get_response_payload(&tracker);
+    test_decode_destroy_request_payload(&tracker);
+    test_decode_destroy_response_payload(&tracker);
+    test_decode_response_batch_item_get_payload(&tracker);
+    test_decode_username_password_credential(&tracker);
+    test_decode_credential_username_password_credential(&tracker);
+    test_decode_authentication_username_password_credential(&tracker);
+    test_decode_request_header(&tracker);
+    test_decode_response_header(&tracker);
+    test_decode_request_batch_item_get_payload(&tracker);
+    test_decode_request_message_get(&tracker);
+    test_decode_response_message_get(&tracker);
+    
+    printf("\n");
+    test_encode_integer(&tracker);
+    test_encode_long(&tracker);
+    test_encode_enum(&tracker);
+    test_encode_bool(&tracker);
+    test_encode_text_string(&tracker);
+    test_encode_byte_string(&tracker);
+    test_encode_date_time(&tracker);
+    test_encode_interval(&tracker);
+    test_encode_name(&tracker);
+    test_encode_attribute_unique_identifier(&tracker);
+    test_encode_attribute_name(&tracker);
+    test_encode_attribute_object_type(&tracker);
+    test_encode_attribute_cryptographic_algorithm(&tracker);
+    test_encode_attribute_cryptographic_length(&tracker);
+    test_encode_attribute_operation_policy_name(&tracker);
+    test_encode_attribute_cryptographic_usage_mask(&tracker);
+    test_encode_attribute_state(&tracker);
+    test_encode_protocol_version(&tracker);
+    test_encode_cryptographic_parameters(&tracker);
+    test_encode_encryption_key_information(&tracker);
+    test_encode_mac_signature_key_information(&tracker);
+    test_encode_key_wrapping_data(&tracker);
+    test_encode_key_material_byte_string(&tracker);
+    test_encode_key_material_transparent_symmetric_key(&tracker);
+    test_encode_key_value(&tracker);
+    test_encode_key_value_with_attributes(&tracker);
+    test_encode_key_block_key_value_byte_string(&tracker);
+    test_encode_key_block_key_value_structure(&tracker);
+    test_encode_symmetric_key(&tracker);
+    test_encode_public_key(&tracker);
+    test_encode_private_key(&tracker);
+    test_encode_key_wrapping_specification(&tracker);
+    test_encode_create_request_payload(&tracker);
+    test_encode_create_response_payload(&tracker);
+    test_encode_create_response_payload_with_template_attribute(&tracker);
+    test_encode_get_request_payload(&tracker);
+    test_encode_get_request_payload_with_format_compression(&tracker);
+    test_encode_get_request_payload_with_wrapping_spec(&tracker);
+    test_encode_get_response_payload(&tracker);
+    test_encode_destroy_request_payload(&tracker);
+    test_encode_destroy_response_payload(&tracker);
+    test_encode_username_password_credential(&tracker);
+    test_encode_credential_username_password_credential(&tracker);
+    test_encode_authentication_username_password_credential(&tracker);
+    test_encode_request_header(&tracker);
+    test_encode_response_header(&tracker);
+    test_encode_request_batch_item_get_payload(&tracker);
+    test_encode_response_batch_item_get_payload(&tracker);
+    test_encode_request_message_get(&tracker);
+    test_encode_response_message_get(&tracker);
+    test_encode_template_attribute(&tracker);
+    
+    printf("\nKMIP 1.1 Feature Tests\n");
+    printf("----------------------\n");
+    test_decode_device_credential(&tracker);
+    test_decode_key_wrapping_data_with_encoding_option(&tracker);
+    
+    printf("\n");
+    test_encode_device_credential(&tracker);
+    test_encode_key_wrapping_data_with_encoding_option(&tracker);
+    test_encode_key_wrapping_specification_with_encoding_option(&tracker);
+    
+    printf("\nKMIP 1.1 Test Suite Test Cases\n");
+    printf("------------------------------\n");
+    test_kmip_1_1_test_suite_3_1_1_0_a(&tracker);
+    test_kmip_1_1_test_suite_3_1_1_0_b(&tracker);
+    test_kmip_1_1_test_suite_3_1_1_1_a(&tracker);
+    test_kmip_1_1_test_suite_3_1_1_1_b(&tracker);
+    test_kmip_1_1_test_suite_3_1_3_2_a(&tracker);
+    test_kmip_1_1_test_suite_3_1_3_2_b(&tracker);
+    
+    printf("\nKMIP 1.2 Feature Tests\n");
+    printf("----------------------\n");
+    test_decode_nonce(&tracker);
+    test_decode_attestation_credential(&tracker);
+    test_decode_response_header_with_attestation_details(&tracker);
+    test_decode_cryptographic_parameters_with_digital_signature_fields(&tracker);
+    
+    printf("\n");
+    test_encode_nonce(&tracker);
+    test_encode_attestation_credential(&tracker);
+    test_encode_request_header_with_attestation_details(&tracker);
+    test_encode_response_header_with_attestation_details(&tracker);
+    test_encode_cryptographic_parameters_with_digital_signature_fields(&tracker);
+    
+    printf("\nKMIP 1.4 Feature Tests\n");
+    printf("----------------------\n");
+    test_decode_cryptographic_parameters_with_mask_fields(&tracker);
+    test_decode_response_header_with_correlation_values(&tracker);
+    
+    printf("\n");
+    test_encode_cryptographic_parameters_with_mask_fields(&tracker);
+    test_encode_get_request_payload_with_wrap_type(&tracker);
+    test_encode_request_header_with_correlation_values(&tracker);
+    test_encode_response_header_with_correlation_values(&tracker);
+    
+    printf("\nKMIP 2.0 Feature Tests\n");
+    printf("----------------------\n");
+    test_decode_protection_storage_masks(&tracker);
+    test_decode_attributes(&tracker);
+    test_decode_attributes_with_invalid_kmip_version(&tracker);
+    test_decode_attribute_v2_unique_identifier(&tracker);
+    test_decode_attribute_v2_name(&tracker);
+    test_decode_attribute_v2_object_type(&tracker);
+    test_decode_attribute_v2_cryptographic_algorithm(&tracker);
+    test_decode_attribute_v2_cryptographic_length(&tracker);
+    test_decode_attribute_v2_cryptographic_usage_mask(&tracker);
+    test_decode_attribute_v2_state(&tracker);
+    test_decode_attribute_v2_unsupported_attribute(&tracker);
+    test_decode_create_request_payload_kmip_2_0(&tracker);
+    test_decode_request_batch_item_get_payload_kmip_2_0(&tracker);
+    test_decode_response_header_kmip_2_0(&tracker);
+
+    printf("\n");
+    test_encode_protection_storage_masks(&tracker);
+    test_encode_attributes(&tracker);
+    test_encode_attributes_with_invalid_kmip_version(&tracker);
+    test_encode_attribute_v2_unique_identifier(&tracker);
+    test_encode_attribute_v2_name(&tracker);
+    test_encode_attribute_v2_object_type(&tracker);
+    test_encode_attribute_v2_cryptographic_algorithm(&tracker);
+    test_encode_attribute_v2_cryptographic_length(&tracker);
+    test_encode_attribute_v2_cryptographic_usage_mask(&tracker);
+    test_encode_attribute_v2_state(&tracker);
+    test_encode_attribute_v2_unsupported_attribute(&tracker);
+    test_encode_create_request_payload_kmip_2_0(&tracker);
+    test_encode_request_batch_item_get_payload_kmip_2_0(&tracker);
+    test_encode_response_header_kmip_2_0(&tracker);
+
+    printf("\nSummary\n");
+    printf("================\n");
+    printf("Total tests: %u\n", tracker.test_count);
+    printf("       PASS: %u\n", tracker.tests_passed);
+    printf("    FAILURE: %u\n", tracker.tests_failed);
+
+    return(tracker.tests_failed);
+}
+
+void
+print_help(const char *app)
+{
+    printf("Usage: %s [flag] ...\n\n", app);
+    printf("Flags:\n");
+    printf("-h : print this help info\n");
+    printf("-i : run the test suite forever\n");
+}
+
+int
+parse_arguments(int argc,
+                char **argv,
+                int *print_usage,
+                int *run_forever)
+{
+    for(int i = 1; i < argc; i++)
+    {
+        if(strncmp(argv[i], "-h", 2) == 0)
+        {
+            *print_usage = 1;
+        }
+        else if(strncmp(argv[i], "-i", 2) == 0)
+        {
+            *run_forever = 1;
+        }
+        else
+        {
+            printf("Invalid option: '%s'\n", argv[i]);
+            print_help(argv[0]);
+            return(-1);
+        }
+    }
+    
+    return(0);
+}
+
+int
+main(int argc, char **argv)
+{
+    int print_usage = 0;
+    int run_forever = 0;
+    
+    int error = parse_arguments(argc, argv, &print_usage, &run_forever);
+    if(error)
+    {
+        return(error);
+    }
+    if(print_usage)
+    {
+        print_help(argv[0]);
+        return(0);
+    }
+    
+    int results = 0;
+    if(run_forever)
+    {
+        while(1)
+        {
+            run_tests();
+        }
+    }
+    else
+    {
+        results = run_tests();
+    }
+
+    return(results);
+}