Merge "Initial commit: cframework. Longbow and Libparc" into cframework/master

1 files changed, 642 insertions, 0 deletions

diff --git a/libparc/parc/algol/test/test_parc_URI.c b/libparc/parc/algol/test/test_parc_URI.c
new file mode 100644
index 00000000..5050deb3
--- /dev/null
+++ b/libparc/parc/algol/test/test_parc_URI.c
@@ -0,0 +1,642 @@
+/*
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ *
+ */
+#include "../parc_URI.c"
+#include <LongBow/unit-test.h>
+
+#include <stdint.h>
+
+#include <parc/algol/parc_Hash.h>
+#include <parc/algol/parc_SafeMemory.h>
+#include <parc/testing/parc_ObjectTesting.h>
+
+#include <parc/algol/parc_Hash.h>
+
+#include "_test_parc_URI.h"
+
+LONGBOW_TEST_RUNNER(parcURI)
+{
+    LONGBOW_RUN_TEST_FIXTURE(parcURI);
+}
+
+LONGBOW_TEST_RUNNER_SETUP(parcURI)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_RUNNER_TEARDOWN(parcURI)
+{
+    uint32_t outstandingAllocations = parcSafeMemory_ReportAllocation(STDERR_FILENO);
+    if (outstandingAllocations != 0) {
+        printf("Tests leak memory by %d allocations\n", outstandingAllocations);
+        return LONGBOW_STATUS_MEMORYLEAK;
+    }
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE(parcURI)
+{
+    LONGBOW_RUN_TEST_CASE(parcURI, parseScheme);
+    LONGBOW_RUN_TEST_CASE(parcURI, parseScheme_Only);
+    LONGBOW_RUN_TEST_CASE(parcURI, parseScheme_BadScheme);
+    LONGBOW_RUN_TEST_CASE(parcURI, parseScheme_EmptyScheme);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parseAuthority);
+    LONGBOW_RUN_TEST_CASE(parcURI, parseAuthority_NoAuthority);
+    LONGBOW_RUN_TEST_CASE(parcURI, parseAuthority_NoPath);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_Acquire);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_AuthorityEquals_SamePointer);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_AuthorityEquals_NullPointers);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_QueryEquals_SamePointer);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_QueryEquals_NullPointers);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_FragmentEquals_SamePointer);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_FragmentEquals_NullPointers);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SchemeEquals_SamePointer);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SchemeEquals_NullPointers);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_Parse);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_Parse_NoScheme);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_Parse_SchemeOnly);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetScheme);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetScheme_Reset);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetScheme_Resetting);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetFragment);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetFragment_Reset);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetFragment_Resetting);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetQuery);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetQuery_Reset);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetQuery_Resetting);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetAuthority);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetAuthority_Reset);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_SetAuthority_Resetting);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_Equals_Contract);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_GetPath);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_GetQuery);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_GetFragment);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_Copy);
+    LONGBOW_RUN_TEST_CASE(parcURI, parcURI_ToString_Full);
+
+    LONGBOW_RUN_TEST_CASE(parcURI, PARCURI_ToString_SchemeOnly);
+    LONGBOW_RUN_TEST_CASE(parcURI, PARCURI_ToString_NoAuthority);
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(parcURI)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(parcURI)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_Acquire)
+{
+    char *uriString = URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT;
+
+    uriString = parcMemory_StringDuplicate(uriString, strlen(uriString));
+
+    PARCURI *uri = parcURI_Parse(uriString);
+
+    PARCURI *handle = parcURI_Acquire(uri);
+
+    assertTrue(parcURI_Equals(uri, handle), "Expected URI and acquired handle to be equal");
+
+    parcURI_Release(&handle);
+    parcURI_Release(&uri);
+    parcMemory_Deallocate((void **) &uriString);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_AuthorityEquals_SamePointer)
+{
+    char *authority = "authority@auth";
+    assertTrue(_parcURI_AuthorityEquals(authority, authority),
+               "Expected authorities to be equal since they're the same pointers: %p - %p",
+               (void *) authority, (void *) authority);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_AuthorityEquals_NullPointers)
+{
+    char *authority = "authority@auth";
+    assertFalse(_parcURI_AuthorityEquals(NULL, authority), "Expected authorities to not be equal since one is NULL");
+    assertFalse(_parcURI_AuthorityEquals(authority, NULL), "Expected authorities to not be equal since one is NULL");
+    assertTrue(_parcURI_AuthorityEquals(NULL, NULL), "Expected authorities to be equal since both are NULL");
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_QueryEquals_SamePointer)
+{
+    char *query = "query";
+    assertTrue(_parcURI_QueryEquals(query, query),
+               "Expected queries to be equal since they're the same pointers: %p - %p",
+               (void *) query, (void *) query);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_QueryEquals_NullPointers)
+{
+    char *query = "query";
+    assertFalse(_parcURI_QueryEquals(NULL, query), "Expected queries to not be equal since one is NULL");
+    assertFalse(_parcURI_QueryEquals(query, NULL), "Expected queries to not be equal since one is NULL");
+    assertTrue(_parcURI_QueryEquals(NULL, NULL), "Expected queries to be equal since both are NULL");
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_FragmentEquals_SamePointer)
+{
+    char *fragment = "fragment";
+    assertTrue(_parcURI_FragmentEquals(fragment, fragment),
+               "Expected fragments to be equal since they're the same pointers: %p - %p",
+               (void *) fragment, (void *) fragment);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_FragmentEquals_NullPointers)
+{
+    char *fragment = "fragment";
+    assertFalse(_parcURI_FragmentEquals(NULL, fragment), "Expected fragments to not be equal since one is NULL");
+    assertFalse(_parcURI_FragmentEquals(fragment, NULL), "Expected fragments to not be equal since one is NULL");
+    assertTrue(_parcURI_FragmentEquals(NULL, NULL), "Expected fragments to be equal since both are NULL");
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SchemeEquals_SamePointer)
+{
+    char *scheme = "scheme";
+    assertTrue(_parcURI_SchemeEquals(scheme, scheme),
+               "Expected schemes to be equal since they're the same pointers: %p - %p",
+               (void *) scheme, (void *) scheme);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SchemeEquals_NullPointers)
+{
+    char *scheme = "scheme";
+    assertFalse(_parcURI_SchemeEquals(NULL, scheme), "Expected schemes to not be equal since one is NULL");
+    assertFalse(_parcURI_SchemeEquals(scheme, NULL), "Expected schemes to not be equal since one is NULL");
+    assertTrue(_parcURI_SchemeEquals(NULL, NULL), "Expected schemes to be equal since both are NULL");
+}
+
+LONGBOW_TEST_CASE(parcURI, parseScheme_EmptyScheme)
+{
+    const char *pointer;
+    char *actual = _parseScheme(":", &pointer); // empty string
+    assertNull(actual, "Parsed scheme should be NULL since the input string was empty.");
+    actual = _parseScheme("", &pointer); // empty string
+    assertNull(actual, "Parsed scheme should be NULL since the input string was empty.");
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_Parse)
+{
+    char *uriString = URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT;
+
+    uriString = parcMemory_StringDuplicate(uriString, strlen(uriString));
+
+    PARCURI *uri = parcURI_Parse(uriString);
+    assertNotNull(uri, "Expected non-null result for '%s'", uriString);
+
+    memset(uriString, 0, strlen(uriString));
+
+    assertTrue(strcmp(URI_SCHEME, parcURI_GetScheme(uri)) == 0,
+               "Expected '%s', actual '%s'", URI_SCHEME, parcURI_GetScheme(uri));
+    assertTrue(strcmp(URI_AUTHORITY, parcURI_GetAuthority(uri)) == 0,
+               "Expected '%s', actual '%s'", URI_AUTHORITY, parcURI_GetAuthority(uri));
+    assertTrue(strcmp(URI_QUERY, parcURI_GetQuery(uri)) == 0,
+               "Expected '%s', actual '%s'", URI_QUERY, parcURI_GetQuery(uri));
+    assertTrue(strcmp(URI_FRAGMENT, parcURI_GetFragment(uri)) == 0,
+               "Expected '%s', actual '%s'", URI_FRAGMENT, parcURI_GetFragment(uri));
+
+    parcMemory_Deallocate((void **) &uriString);
+
+    parcURI_Release(&uri);
+    assertNull(uri, "Expected parcURI_Release to null the pointer.");
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_Parse_NoScheme)
+{
+    char *uriString = "/" URI_PATH_SEGMENT;
+
+    uriString = parcMemory_StringDuplicate(uriString, strlen(uriString));
+
+    PARCURI *uri = parcURI_Parse(uriString);
+    assertNull(uri,
+               "Expected null result for '%s'", uriString);
+    parcMemory_Deallocate((void **) &uriString);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_Parse_SchemeOnly)
+{
+    char *uriString = URI_SCHEME ":";
+
+    uriString = parcMemory_StringDuplicate(uriString, strlen(uriString));
+
+    PARCURI *uri = parcURI_Parse(uriString);
+    assertNotNull(uri,
+                  "Expected non-null result for '%s'", uriString);
+
+    memset(uriString, 0, strlen(uriString));
+
+    assertTrue(strcmp(URI_SCHEME, parcURI_GetScheme(uri)) == 0,
+               "Expected '%s', actual '%s'", URI_SCHEME, parcURI_GetScheme(uri));
+    assertNull(parcURI_GetAuthority(uri),
+               "Expected NULL, actual '%s'", parcURI_GetAuthority(uri));
+    assertNull(parcURI_GetQuery(uri),
+               "Expected NULL, actual '%s'", parcURI_GetQuery(uri));
+    assertNull(parcURI_GetFragment(uri),
+               "Expected NULL, actual '%s'", parcURI_GetFragment(uri));
+
+    parcMemory_Deallocate((void **) &uriString);
+    parcURI_Release(&uri);
+    assertNull(uri,
+               "Expected parcURI_Release to null the pointer.");
+}
+
+LONGBOW_TEST_CASE(parcURI, parseScheme)
+{
+    const char *pointer;
+    char *actual = _parseScheme(URI_FULL, &pointer);
+    assertTrue(strcmp(URI_SCHEME, actual) == 0,
+               "Expected '%s' actual '%s'", URI_SCHEME, actual);
+    parcMemory_Deallocate((void **) &actual);
+}
+
+LONGBOW_TEST_CASE(parcURI, parseScheme_Only)
+{
+    const char *pointer;
+    char *actual = _parseScheme(URI_SCHEME ":", &pointer);
+    assertTrue(strcmp(URI_SCHEME, actual) == 0,
+               "Expected '%s' actual '%s'", URI_SCHEME, actual);
+    parcMemory_Deallocate((void **) &actual);
+}
+
+LONGBOW_TEST_CASE(parcURI, parseScheme_BadScheme)
+{
+    const char *pointer;
+    char *actual = _parseScheme("", &pointer);
+    assertNull(actual,
+               "Expected NULL actual '%s'", actual);
+}
+
+LONGBOW_TEST_CASE(parcURI, PARCURI_GetAuthority)
+{
+    PARCURI *uri = parcURI_Parse(URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT);
+    const char *actual = parcURI_GetAuthority(uri);
+    assertTrue(strcmp(TEST_URI_AUTHORITY, actual) == 0,
+               "Expected '%s' actual '%s'", URI_AUTHORITY, actual);
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_GetQuery)
+{
+    PARCURI *uri = parcURI_Parse(URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT);
+    const char *actual = parcURI_GetQuery(uri);
+    assertTrue(strcmp(URI_QUERY, actual) == 0,
+               "Expected '%s' actual '%s'", URI_FRAGMENT, actual);
+
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_GetFragment)
+{
+    PARCURI *uri = parcURI_Parse(URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT);
+    const char *actual = parcURI_GetFragment(uri);
+    assertTrue(strcmp(URI_FRAGMENT, actual) == 0,
+               "Expected '%s' actual '%s'", URI_FRAGMENT, actual);
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_GetPath)
+{
+    char *uriString = URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT;
+    PARCURI *uri = parcURI_Parse(uriString);
+    PARCURIPath *actual = parcURI_GetPath(uri);
+
+    char *string = parcURIPath_ToString(actual);
+
+    char *expected = URI_PATH_SEGMENT "/" URI_PATH_SEGMENT;
+    assertTrue(strcmp(expected, string) == 0, "Expected '%s' actual '%s'", expected, string);
+
+    parcMemory_Deallocate((void **) &string);
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_Copy)
+{
+    PARCURI *uri = parcURI_Parse(URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT);
+    PARCURI *uri2 = parcURI_Copy(uri);
+
+    char *expected = parcURI_ToString(uri);
+    char *actual = parcURI_ToString(uri2);
+
+    assertTrue(strcmp(expected, actual) == 0,
+               "Expected '%s' actual '%s'", expected, actual);
+    parcMemory_Deallocate((void **) &expected);
+    parcMemory_Deallocate((void **) &actual);
+    parcURI_Release(&uri);
+    parcURI_Release(&uri2);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_Equals_Contract)
+{
+    PARCURI *x = parcURI_Parse(URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT);
+    PARCURI *y = parcURI_Parse(URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT);
+    PARCURI *z = parcURI_Parse(URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT);
+    PARCURI *u = parcURI_Parse(URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "?" URI_QUERY);
+
+    parcObjectTesting_AssertEqualsFunction(parcURI_Equals, x, y, z, u);
+
+    parcURI_Release(&x);
+    parcURI_Release(&y);
+    parcURI_Release(&z);
+    parcURI_Release(&u);
+}
+
+LONGBOW_TEST_CASE(parcURI, PARCURI_GetScheme)
+{
+    PARCURI *uri = parcURI_Parse(URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT);
+    const char *actual = parcURI_GetScheme(uri);
+    assertTrue(strcmp(TEST_URI_SCHEME, actual) == 0,
+               "Expected '%s' actual '%s'", TEST_URI_SCHEME, actual);
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, PARCURI_Parse)
+{
+    PARCURI *uri = parcURI_Parse(URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT);
+    assertNotNull(uri,
+                  "Expected a non-null result.");
+
+    assertTrue(strcmp(URI_SCHEME, parcURI_GetScheme(uri)) == 0,
+               "Expected '%s', actual '%s'", URI_SCHEME, parcURI_GetScheme(uri));
+    assertTrue(strcmp(URI_AUTHORITY, parcURI_GetAuthority(uri)) == 0,
+               "Expected '%s', actual '%s'", URI_AUTHORITY, parcURI_GetAuthority(uri));
+    assertTrue(strcmp(URI_QUERY, parcURI_GetQuery(uri)) == 0,
+               "Expected '%s', actual '%s'", URI_QUERY, parcURI_GetQuery(uri));
+    assertTrue(strcmp(URI_FRAGMENT, parcURI_GetFragment(uri)) == 0,
+               "Expected '%s', actual '%s'", URI_FRAGMENT, parcURI_GetFragment(uri));
+
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_ToString_Full)
+{
+    char *expected = URI_SCHEME "://" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT;
+
+    PARCURI *uri = parcURI_Parse(expected);
+    char *actual = parcURI_ToString(uri);
+
+    assertTrue(strcmp(expected, actual) == 0,
+               "Expected '%s' actual '%s'", expected, actual);
+    parcMemory_Deallocate((void **) &actual);
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, PARCURI_ToString_SchemeOnly)
+{
+    char *expected = URI_SCHEME ":" "/";
+    PARCURI *uri = parcURI_Parse(expected);
+    char *actual = parcURI_ToString(uri);
+
+    assertTrue(strcmp(expected, actual) == 0,
+               "Expected '%s' actual '%s'", expected, actual);
+    parcURI_Release(&uri);
+    parcMemory_Deallocate((void **) &actual);
+}
+
+LONGBOW_TEST_CASE(parcURI, PARCURI_ToString_NoAuthority)
+{
+    char *expected = URI_SCHEME ":" "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT "?" URI_QUERY "#" URI_FRAGMENT;
+    PARCURI *uri = parcURI_Parse(expected);
+    char *actual = parcURI_ToString(uri);
+
+    assertTrue(strcmp(expected, actual) == 0,
+               "Expected '%s' actual '%s'", expected, actual);
+
+    parcURI_Release(&uri);
+    parcMemory_Deallocate((void **) &actual);
+}
+
+LONGBOW_TEST_CASE(parcURI, parseAuthority)
+{
+    char *authority = "//" URI_AUTHORITY "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT;
+    char *expected = URI_AUTHORITY;
+
+    const char *pointer;
+    char *actual = _parseAuthority(authority, &pointer);
+    assertTrue(strcmp(expected, actual) == 0,
+               "Expected '%s' actual '%s'", expected, actual);
+    assertTrue(*pointer == '/',
+               "Expected '/' actual '%c'", *pointer);
+    parcMemory_Deallocate((void **) &actual);
+}
+
+LONGBOW_TEST_CASE(parcURI, parseAuthority_NoAuthority)
+{
+    char *string = "/" URI_PATH_SEGMENT "/" URI_PATH_SEGMENT;
+
+    const char *pointer;
+    char *actual = _parseAuthority(string, &pointer);
+    assertTrue(actual == NULL,
+               "Expected NULL actual '%s'", actual);
+    assertTrue(*pointer == '/',
+               "Expected '/' actual '%c'", *pointer);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetScheme)
+{
+    char *scheme = "scheme";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetScheme(uri, scheme);
+
+    assertTrue(strcmp(scheme, parcURI_GetScheme(uri)) == 0,
+               "Expected %s actual %s", scheme, parcURI_GetScheme(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetScheme_Resetting)
+{
+    char *scheme = "scheme";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetScheme(uri, scheme);
+    _parcURI_SetScheme(uri, scheme);
+
+    assertTrue(strcmp(scheme, parcURI_GetScheme(uri)) == 0,
+               "Expected %s actual %s", scheme, parcURI_GetScheme(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetScheme_Reset)
+{
+    char *scheme = "scheme";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetScheme(uri, scheme);
+    _parcURI_SetScheme(uri, NULL);
+
+    assertNull(parcURI_GetScheme(uri),
+               "Expected NULL actual %s", parcURI_GetScheme(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetFragment)
+{
+    char *fragment = "fragment";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetFragment(uri, fragment);
+
+    assertTrue(strcmp(fragment, parcURI_GetFragment(uri)) == 0,
+               "Expected %s actual %s", fragment, parcURI_GetFragment(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetFragment_Resetting)
+{
+    char *fragment = "fragment";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetFragment(uri, fragment);
+    _parcURI_SetFragment(uri, fragment);
+
+    assertTrue(strcmp(fragment, parcURI_GetFragment(uri)) == 0,
+               "Expected %s actual %s", fragment, parcURI_GetFragment(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetFragment_Reset)
+{
+    char *fragment = "query";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetFragment(uri, fragment);
+    _parcURI_SetFragment(uri, NULL);
+
+    assertNull(parcURI_GetFragment(uri),
+               "Expected NULL actual %s", parcURI_GetFragment(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetQuery)
+{
+    char *query = "query";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetQuery(uri, query);
+
+    assertTrue(strcmp(query, parcURI_GetQuery(uri)) == 0,
+               "Expected %s actual %s", query, parcURI_GetQuery(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetQuery_Resetting)
+{
+    char *query = "query";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetQuery(uri, query);
+    _parcURI_SetQuery(uri, query);
+
+    assertTrue(strcmp(query, parcURI_GetQuery(uri)) == 0,
+               "Expected %s actual %s", query, parcURI_GetQuery(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetQuery_Reset)
+{
+    char *query = "query";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetQuery(uri, query);
+    _parcURI_SetQuery(uri, NULL);
+
+    assertNull(parcURI_GetQuery(uri),
+               "Expected NULL actual %s", parcURI_GetQuery(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetAuthority)
+{
+    char *authority = "authority@auth";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetAuthority(uri, authority);
+
+    assertTrue(strcmp(authority, parcURI_GetAuthority(uri)) == 0,
+               "Expected %s actual %s", authority, parcURI_GetAuthority(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetAuthority_Resetting)
+{
+    char *authority = "query";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetAuthority(uri, authority);
+    _parcURI_SetAuthority(uri, authority);
+
+    assertTrue(strcmp(authority, parcURI_GetAuthority(uri)) == 0,
+               "Expected %s actual %s", authority, parcURI_GetAuthority(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parcURI_SetAuthority_Reset)
+{
+    char *query = "query";
+    PARCURI *uri = parcURI_Create();
+    _parcURI_SetAuthority(uri, query);
+    _parcURI_SetAuthority(uri, NULL);
+
+    assertNull(parcURI_GetAuthority(uri),
+               "Expected NULL actual %s", parcURI_GetAuthority(uri));
+    parcURI_Release(&uri);
+}
+
+LONGBOW_TEST_CASE(parcURI, parseAuthority_NoPath)
+{
+    char *authority = "//" URI_AUTHORITY;
+    char *expected = URI_AUTHORITY;
+
+    const char *pointer;
+    char *actual = _parseAuthority(authority, &pointer);
+
+    assertTrue(strcmp(expected, actual) == 0,
+               "Expected '%s' actual '%s'", authority, actual);
+    assertTrue(*pointer == 0,
+               "Expected null actual '%c'", *pointer);
+    parcMemory_Deallocate((void **) &actual);
+}
+
+LONGBOW_TEST_CASE(parcURI, parseFragment)
+{
+    testUnimplemented("This test is unimplemented");
+}
+
+LONGBOW_TEST_CASE(parcURI, parsePath)
+{
+    testUnimplemented("This test is unimplemented");
+}
+
+LONGBOW_TEST_CASE(parcURI, parseQuery)
+{
+    testUnimplemented("This test is unimplemented");
+}
+
+int
+main(int argc, char *argv[])
+{
+    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parcURI);
+    int status = LONGBOW_TEST_MAIN(argc, argv, testRunner);
+    longBowTestRunner_Destroy(&testRunner);
+    exit(status);
+}