diff --git a/test/test_ion_binary.cpp b/test/test_ion_binary.cpp
index c965232..4425914 100644
--- a/test/test_ion_binary.cpp
+++ b/test/test_ion_binary.cpp
@@ -61,6 +61,8 @@ TEST(IonWriterAddAnnotation, SameInTextAndBinary) {
     ION_ASSERT_OK(ion_event_stream_read_all_from_bytes(binary_data, binary_len, NULL, &binary_stream));
     ION_ASSERT_OK(ion_event_stream_read_all_from_bytes(text_data, text_len, NULL, &text_stream));
     ASSERT_TRUE(ion_compare_streams(&binary_stream, &text_stream));
+    free(binary_data);
+    free(text_data);
 }
 
 TEST(IonBinaryTimestamp, WriterConvertsToUTC) {
@@ -79,6 +81,8 @@ TEST(IonBinaryTimestamp, WriterConvertsToUTC) {
 
     // Expected: 2008-02-29T23:59 with offset of +1 minutes.
     assertBytesEqual("\xE0\x01\x00\xEA\x67\x81\x0F\xD8\x82\x9D\x97\xBB", 12, result, result_len);
+
+    free(result);
 }
 
 TEST(IonBinaryTimestamp, ReaderConvertsFromUTC) {
@@ -115,6 +119,8 @@ TEST(IonBinaryTimestamp, WriterIgnoresSuperfluousOffset) {
 
     // Expected: 0001T with unknown local offset (C0 == -0 == unknown local offset).
     assertBytesEqual("\xE0\x01\x00\xEA\x62\xC0\x81", 7, result, result_len);
+
+    free(result);
 }
 
 TEST(IonBinaryTimestamp, ReaderIgnoresSuperfluousOffset) {
@@ -149,6 +155,7 @@ TEST(IonBinarySymbol, WriterWritesSymbolValueThatLooksLikeSymbolZero) {
     // NOTE: the symbol value refers to \x0A (i.e. SID 10 -- a local symbol), NOT \x00 (SID 0). This is because the
     // ion_writer_write_symbol API, which takes a string from the user, was used.
     assertBytesEqual("\x71\x0A", 2, result + result_len - 2, 2);
+    free(result);
 }
 
 TEST(IonBinarySymbol, WriterWritesSymbolValueSymbolZero) {
@@ -163,6 +170,7 @@ TEST(IonBinarySymbol, WriterWritesSymbolValueSymbolZero) {
 
     // NOTE: symbol zero is NOT added to the local symbol table. Symbol zero is not present in ANY symbol table.
     assertBytesEqual("\xE0\x01\x00\xEA\x70", 5, result, result_len);
+    free(result);
 }
 
 TEST(IonBinarySymbol, WriterWritesAnnotationThatLooksLikeSymbolZero) {
@@ -182,6 +190,7 @@ TEST(IonBinarySymbol, WriterWritesAnnotationThatLooksLikeSymbolZero) {
     // NOTE: the annotation refers to \x8A (i.e. SID 10 -- a local symbol), NOT \x80 (SID 0). This is because the
     // ion_writer_add_annotation API, which takes a string from the user, was used.
     assertBytesEqual("\xE3\x81\x8A\x70", 4, result + result_len - 4, 4);
+    free(result);
 }
 
 TEST(IonBinarySymbol, WriterWritesAnnotationSymbolZero) {
@@ -197,6 +206,7 @@ TEST(IonBinarySymbol, WriterWritesAnnotationSymbolZero) {
 
     // NOTE: symbol zero is NOT added to the local symbol table. Symbol zero is not present in ANY symbol table.
     assertBytesEqual("\xE0\x01\x00\xEA\xE3\x81\x80\x70", 8, result, result_len);
+    free(result);
 }
 
 TEST(IonBinarySymbol, WriterWritesFieldNameThatLooksLikeSymbolZero) {
@@ -219,6 +229,7 @@ TEST(IonBinarySymbol, WriterWritesFieldNameThatLooksLikeSymbolZero) {
     // NOTE: the field name and annotation refer to \x8A (i.e. SID 10 -- a local symbol), NOT \x80 (SID 0).
     // This is due to use of APIs that accept a string from the user.
     assertBytesEqual("\xD5\x8A\xE3\x81\x8A\x70", 6, result + result_len - 6, 6);
+    free(result);
 }
 
 TEST(IonBinarySymbol, WriterWritesFieldNameSymbolZero) {
@@ -237,6 +248,7 @@ TEST(IonBinarySymbol, WriterWritesFieldNameSymbolZero) {
 
     // NOTE: symbol zero is NOT added to the local symbol table. Symbol zero is not present in ANY symbol table.
     assertBytesEqual("\xE0\x01\x00\xEA\xD5\x80\xE3\x81\x80\x70", 10, result, result_len);
+    free(result);
 }
 
 TEST(IonBinarySymbol, ReaderReadsSymbolValueZeroAsString) {
@@ -293,6 +305,7 @@ TEST(IonBinarySymbol, WriterWritesSymbolValueIVM) {
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, ion_stream, &result, &result_len));
 
     assertBytesEqual("\xE0\x01\x00\xEA\x20\x21\x01\x21\x02", 9, result, result_len);
+    free(result);
 }
 
 TEST(IonBinarySymbol, ReaderReadsSymbolValueIVMNoOpAtEOF) {
@@ -345,6 +358,7 @@ TEST(IonBinaryReader, UnpositionedReaderHasTypeNone) {
     ION_ASSERT_OK(ion_reader_open_buffer(&reader, data, 4, NULL));
     ION_ASSERT_OK(ion_reader_get_type(reader, &type));
     ASSERT_EQ(tid_none, type);
+    ION_ASSERT_OK(ion_reader_close(reader));
 }
 
 TEST(IonBinarySymbol, ReaderReadsNullSymbol) {
@@ -392,6 +406,7 @@ void test_ion_binary_write_from_reader_rejects_negative_zero_int(BYTE *data, siz
     ION_ASSERT_FAIL(ion_writer_write_one_value(writer, reader));
     ION_ASSERT_OK(ion_writer_close(writer));
     ION_ASSERT_OK(ion_reader_close(reader));
+    ION_ASSERT_OK(ion_stream_close(stream));
 }
 
 TEST(IonBinaryInt, ReaderRejectsNegativeZeroMixedIntOneByte) {
@@ -406,7 +421,7 @@ void test_ion_binary_reader_threshold_for_int64_as_big_int(BYTE *data, size_t le
     hREADER reader;
     ION_TYPE type;
     int64_t value;
-    ION_INT big_int_expected;
+    ION_INT *big_int_expected;
     SIZE str_len, written;
 
     ION_ASSERT_OK(ion_reader_open_buffer(&reader, data, len, NULL));
@@ -417,16 +432,21 @@ void test_ion_binary_reader_threshold_for_int64_as_big_int(BYTE *data, size_t le
     ASSERT_EQ(IERR_NUMERIC_OVERFLOW,ion_reader_read_int64(reader, &value));
 
     // initialize ION_INT and read it as big integer
-    ION_ASSERT_OK(ion_int_init(&big_int_expected, NULL));
-    ION_ASSERT_OK(ion_reader_read_ion_int(reader, &big_int_expected));
+    ION_ASSERT_OK(ion_int_alloc(NULL, &big_int_expected));
+    ION_ASSERT_OK(ion_int_init(big_int_expected, NULL));
+    ION_ASSERT_OK(ion_reader_read_ion_int(reader, big_int_expected));
+    ION_ASSERT_OK(ion_reader_close(reader));
 
     // convert big integer to string for comparison
-    ion_int_char_length(&big_int_expected, &str_len);
+    ion_int_char_length(big_int_expected, &str_len);
     char *int_str = (char *)malloc(str_len * sizeof(char));
-    ion_int_to_char(&big_int_expected, (BYTE *)int_str, str_len, &written);
+    ion_int_to_char(big_int_expected, (BYTE *)int_str, str_len, &written);
+    ion_int_free(big_int_expected);
 
     // compare string representation of the value
     ASSERT_STREQ(actual_value, int_str);
+
+    free(int_str);
 }
 
 void test_ion_binary_reader_threshold_for_int64_as_int64(BYTE *data, size_t len, int64_t actual_value) {
@@ -443,6 +463,8 @@ void test_ion_binary_reader_threshold_for_int64_as_int64(BYTE *data, size_t len,
 
     // compare actual and generated int64 values
     ASSERT_EQ(actual_value, value);
+
+    ION_ASSERT_OK(ion_reader_close(reader));
 }
 
 TEST(IonBinaryReader, ReaderPositiveThresholdForInt64) {
@@ -468,6 +490,7 @@ void test_ion_binary_reader_requires_timestamp_fraction_less_than_one(BYTE *data
     ION_ASSERT_OK(ion_reader_next(reader, &type));
     ASSERT_EQ(tid_TIMESTAMP, type);
     ASSERT_EQ(IERR_INVALID_BINARY, ion_reader_read_timestamp(reader, &ts));
+    ION_ASSERT_OK(ion_reader_close(reader));
 }
 
 TEST(IonBinaryTimestamp, ReaderRequiresTimestampFractionLessThanOne) {
@@ -489,6 +512,7 @@ void test_ion_binary_reader_supports_32_bit_floats(BYTE *data, size_t len, float
     ASSERT_EQ(tid_FLOAT, type);
     ION_ASSERT_OK(ion_reader_read_double(reader, &actual));
     ASSERT_FLOAT_EQ(expected, (float) actual);
+    ION_ASSERT_OK(ion_reader_close(reader));
 }
 
 TEST(IonBinaryFloat, ReaderSupports32BitFloats) {
@@ -526,6 +550,7 @@ TEST(IonBinaryFloat, ReaderSupports32BitFloatNan) {
     ION_ASSERT_OK(ion_reader_read_double(reader, &actual));
     ASSERT_TRUE(std::isnan(nan));
     ASSERT_TRUE(std::isnan(actual));
+    ION_ASSERT_OK(ion_reader_close(reader));
 }
 
 /**
@@ -619,6 +644,8 @@ void test_ion_binary_writer_supports_32_bit_floats(float value, const char *expe
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, ion_stream, &result, &result_len));
 
     assertBytesEqual(expected, expected_len, result, result_len);
+
+    free(result);
 }
 
 
@@ -662,6 +689,8 @@ void test_ion_binary_writer_supports_compact_floats(BOOL compact_floats, double
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, ion_stream, &result, &result_len));
 
     assertBytesEqual(expected, expected_len, result, result_len);
+
+    free(result);
 }
 
 TEST(IonBinaryFloat, WriterSupportsCompactFloatsOption) {
diff --git a/test/test_ion_cli.cpp b/test/test_ion_cli.cpp
index 2dc2f1a..20e5842 100644
--- a/test/test_ion_cli.cpp
+++ b/test/test_ion_cli.cpp
@@ -471,6 +471,7 @@ TEST(IonCli, ProcessSymbolsWithUnknownTextWithoutCatalog) {
     test_ion_cli_process(filepath.c_str(), IO_TYPE_FILE, &command_output, &report, OUTPUT_TYPE_EVENTS);
     ASSERT_FALSE(report.hasComparisonFailures());
     ASSERT_FALSE(report.hasErrors());
+
     IonCliCommonArgs common_args;
     test_ion_cli_init_common_args(&common_args);
     IonEventStream stream;
@@ -507,11 +508,14 @@ TEST(IonCli, FirstValueHasError) {
     ASSERT_FALSE(report1.hasComparisonFailures());
     ASSERT_TRUE(report1.hasErrors());
     char *events = ion_string_strdup(&command_output);
+    ion_cli_free_command_output(&command_output);
     test_ion_cli_process(events, IO_TYPE_MEMORY, &command_output, &report2);
     ASSERT_FALSE(report2.hasComparisonFailures());
     ASSERT_FALSE(report2.hasErrors());
     ASSERT_EQ(0, command_output.length);
     free(events);
+
+    ion_cli_free_command_output(&command_output);
 }
 
 TEST(IonCli, ParsingFailureDoesNotYieldEvent) {
@@ -523,11 +527,14 @@ TEST(IonCli, ParsingFailureDoesNotYieldEvent) {
     ASSERT_FALSE(report1.hasComparisonFailures());
     ASSERT_TRUE(report1.hasErrors());
     char *events = ion_string_strdup(&command_output);
+    ion_cli_free_command_output(&command_output);
     test_ion_cli_process(events, IO_TYPE_MEMORY, &command_output, &report2);
     ASSERT_FALSE(report2.hasComparisonFailures());
     ASSERT_FALSE(report2.hasErrors());
     ASSERT_EQ(0, command_output.length);
     free(events);
+
+    ion_cli_free_command_output(&command_output);
 }
 
 TEST(IonCli, ComparingBadListWithElementsFromEventStreamSucceeds) {
@@ -543,6 +550,8 @@ TEST(IonCli, ComparingBadListWithElementsFromEventStreamSucceeds) {
     ASSERT_FALSE(report2.hasComparisonFailures());
     ASSERT_FALSE(report2.hasErrors());
     free(events);
+
+    ion_cli_free_command_output(&command_output);
 }
 
 TEST(IonCli, ComparingBadListWithoutElementsFromEventStreamSucceeds) {
@@ -558,6 +567,8 @@ TEST(IonCli, ComparingBadListWithoutElementsFromEventStreamSucceeds) {
     ASSERT_FALSE(report2.hasComparisonFailures());
     ASSERT_FALSE(report2.hasErrors());
     free(events);
+
+    ion_cli_free_command_output(&command_output);
 }
 
 TEST(IonCli, ComparingSymbolZeroFromEventStreamSucceeds) {
@@ -573,6 +584,7 @@ TEST(IonCli, ComparingSymbolZeroFromEventStreamSucceeds) {
     ASSERT_FALSE(report2.hasComparisonFailures());
     ASSERT_FALSE(report2.hasErrors());
     free(events);
+    ion_cli_free_command_output(&command_output);
 }
 
 TEST(IonCli, ComparingInnerVersionMarkersSucceeds) {
@@ -588,4 +600,6 @@ TEST(IonCli, ComparingInnerVersionMarkersSucceeds) {
     ASSERT_FALSE(report2.hasComparisonFailures());
     ASSERT_FALSE(report2.hasErrors());
     free(events);
+
+    ion_cli_free_command_output(&command_output);
 }
diff --git a/test/test_ion_decimal.cpp b/test/test_ion_decimal.cpp
index c69138c..3aca2c8 100644
--- a/test/test_ion_decimal.cpp
+++ b/test/test_ion_decimal.cpp
@@ -123,12 +123,15 @@
     ION_ASSERT_OK(ion_writer_write_ion_decimal(writer, &ion_decimal)); \
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, ion_stream, &result, &result_len));
 
+
 #define ION_DECIMAL_BINARY_READER_EXPECT_OVERFLOW(func, decimal_digits) \
     ION_DECIMAL_TEXT_TO_BINARY(decimal_digits); \
+    ION_ASSERT_OK(ion_reader_close(reader)); \
+    reader = NULL; \
     /* This new reader only supports decQuad precision, which the input exceeds. */ \
     ION_DECIMAL_EXPECT_OVERFLOW(func, DECQUAD_Pmax); \
     free(result); \
-    ION_DECIMAL_FREE_1(&ion_decimal); \
+    ION_DECIMAL_FREE_1(&ion_decimal);
 
 
 /* Reading/writing tests */
diff --git a/test/test_ion_extractor.cpp b/test/test_ion_extractor.cpp
index 3b9990b..e7b8308 100644
--- a/test/test_ion_extractor.cpp
+++ b/test/test_ion_extractor.cpp
@@ -564,7 +564,6 @@ TEST(IonExtractorSucceedsWhen, ARelativePathMatches) {
     ION_ASSERT_OK(ion_reader_next(reader, &type)); // foo
     ASSERT_EQ(tid_STRUCT, type);
     ION_ASSERT_OK(ion_reader_step_in(reader)); //bar
-    ION_ASSERT_OK(ion_extractor_open(&extractor, &options));
 
     ION_EXTRACTOR_TEST_PATH_FROM_TEXT("(baz)", &assertMatchesInt1or3);
     ION_EXTRACTOR_TEST_PATH_FROM_TEXT("(foo bar baz)", &assertPathNeverMatches); // Never matches because the extractor is scoped at depth 2.
diff --git a/test/test_ion_integer.cpp b/test/test_ion_integer.cpp
index fb15d44..d7464c8 100644
--- a/test/test_ion_integer.cpp
+++ b/test/test_ion_integer.cpp
@@ -64,18 +64,25 @@ iERR test_ion_int_to_int64_t_overflow_detection(const char * p_chars) {
     const uint32_t max_string_length = 32;
     uint32_t string_length = strnlen(p_chars, max_string_length);
     // Create an uninitialized Ion integer.
-    ION_INT iint;
+    ION_INT *iint = NULL;
     // Create an int64_t that we will later populate with the value of iint.
     int64_t value_out;
+
+    // Allocate ION_INT on the heap so we don't have to free the inner data manually.
+    ion_int_alloc(NULL, &iint);
     // Initialize the Ion integer, setting its owner to NULL.
-    IONCHECK(ion_int_init(&iint, NULL));
+    IONCHECK(ion_int_init(iint, NULL));
     // Populate the Ion integer with the value of the provided base-10 string
-    IONCHECK(ion_int_from_chars(&iint, p_chars, string_length));
+    IONCHECK(ion_int_from_chars(iint, p_chars, string_length));
     // Attempt to read the Ion integer's value back out into the int64_t.
     // If the number is outside the range of values that can be represented by
     // an int64_t, this should return IERR_NUMERIC_OVERFLOW.
-    IONCHECK(ion_int_to_int64(&iint, &value_out));
-    iRETURN;
+    IONCHECK(ion_int_to_int64(iint, &value_out));
+
+fail:
+    ion_int_free(iint);
+
+    RETURN(__location_name__, __line__, __count__++, err);
 }
 
 TEST(IonInteger, IIntToInt64Overflow) {
@@ -118,4 +125,4 @@ TEST(IonInteger, IIntToInt64Overflow) {
         iERR error_value = test_ion_int_to_int64_t_overflow_detection(oversized_integer);
         ASSERT_EQ(error_value, IERR_NUMERIC_OVERFLOW);
     }
-}
\ No newline at end of file
+}
diff --git a/test/test_ion_reader_seek.cpp b/test/test_ion_reader_seek.cpp
index 5febdd5..30a3f08 100644
--- a/test/test_ion_reader_seek.cpp
+++ b/test/test_ion_reader_seek.cpp
@@ -603,6 +603,9 @@ TEST_P(TextAndBinary, ReaderHandlesContainerValueOffsetSeek) {
     ION_ASSERT_OK(ion_reader_seek(reader, pos_second, -1));
     ION_ASSERT_OK(ion_reader_next(reader, &type));
     ASSERT_EQ(tid_SYMBOL, type);
+
+    ION_ASSERT_OK(ion_reader_close(reader));
+    free(data);
 }
 
 TEST_P(TextAndBinary, ReaderHandlesInitialUnannotatedContainerValueOffsetSeek) {
@@ -679,6 +682,8 @@ TEST_P(TextAndBinary, ReaderHandlesInitialUnannotatedContainerValueOffsetSeek) {
     ION_ASSERT_OK(ion_reader_seek(reader, pos_second, -1));
     ION_ASSERT_OK(ion_reader_next(reader, &type));
     ASSERT_EQ(tid_SYMBOL, type);
+    ION_ASSERT_OK(ion_reader_close(reader));
+    free(data);
 }
 
 TEST_P(TextAndBinary, ReaderPopulatesStructFieldsOnSeek) {
@@ -709,7 +714,7 @@ TEST_P(TextAndBinary, ReaderPopulatesStructFieldsOnSeek) {
     hREADER reader = NULL;
     ION_TYPE type;
     POSITION pos_field1, pos_field2;
-    ION_STRING read_field1, read_val1, read_field2, read_val2;
+    ION_STRING read_val1, read_val2;
 
     // We use this reader to capture offsets
     ION_ASSERT_OK(ion_test_new_reader(data, data_length, &reader));
@@ -751,10 +756,14 @@ TEST_P(TextAndBinary, ReaderPopulatesStructFieldsOnSeek) {
     char *cread_val2 = ion_string_strdup(&read_val2);
 
     ION_ASSERT_OK(ion_reader_close(reader));
+    free(data);
 
     // Assert:
 
     // Easy assertions: there's only one value, "value," and we should have read it both times
     assertStringsEqual((char *)value1.value, cread_val1, strlen(cread_val1));
     assertStringsEqual((char *)value2.value, cread_val2, strlen(cread_val2));
-}
\ No newline at end of file
+
+    free(cread_val1);
+    free(cread_val2);
+}
diff --git a/test/test_ion_symbol.cpp b/test/test_ion_symbol.cpp
index 4bac8c1..aea4713 100644
--- a/test/test_ion_symbol.cpp
+++ b/test/test_ion_symbol.cpp
@@ -343,6 +343,8 @@ TEST_P(BinaryAndTextTest, ManuallyWritingSymbolTableStructWithImportsIsRecognize
     ION_ASSERT_OK(ion_test_writer_write_symbol_sid(writer, 10)); // This maps to sym1.
 
     ION_SYMBOL_TEST_REWRITE_WITH_CATALOG_FROM_WRITER_AND_ASSERT_TEXT("$ion_symbol_table::{imports:[{name:\"import1\",version:1,max_id:1}]} sym1");
+
+    ION_ASSERT_OK(ion_catalog_close(catalog));
 }
 
 TEST_P(BinaryAndTextTest, ManuallyWritingSymbolTableStructWithImportsAndOpenContentIsRecognizedAsSymbolTable) {
@@ -437,6 +439,7 @@ TEST_P(BinaryAndTextTest, ManuallyWritingSymbolTableStructWithImportsAndOpenCont
     ION_ASSERT_OK(ion_reader_read_ion_symbol(reader, &symbol));
     ION_ASSERT_OK(ion_writer_write_ion_symbol(roundtrip_writer, &symbol));
     ION_ASSERT_OK(ion_reader_close(reader));
+    ION_ASSERT_OK(ion_catalog_close(catalog));
     free(result);
 
     ION_ASSERT_OK(ion_test_writer_get_bytes(roundtrip_writer, stream, &result, &bytes_flushed));
@@ -567,6 +570,7 @@ TEST_P(BinaryAndTextTest, ManuallyWritingAmbiguousImportFails) {
     ION_ASSERT_OK(ion_writer_write_int(writer, 1));
     ASSERT_EQ(IERR_INVALID_SYMBOL_TABLE, ion_writer_finish_container(writer));
     ASSERT_EQ(IERR_UNEXPECTED_EOF, ion_writer_close(writer));
+    ion_stream_close(stream);
 }
 
 TEST_P(BinaryAndTextTest, ManuallyWriteSymbolTableAppendSucceeds) {
@@ -680,6 +684,7 @@ TEST_P(BinaryAndTextTest, SymbolTableGettersWithManualLSTInProgressReturnsPrevio
     ASSERT_NE(symbol_table_1, symbol_table_2);
 
     ION_ASSERT_OK(ion_writer_close(writer));
+    ION_ASSERT_OK(ion_stream_close(stream));
 }
 
 TEST_P(BinaryAndTextTest, SymbolTableSetterWithManualLSTInProgressFails) {
@@ -700,6 +705,7 @@ TEST_P(BinaryAndTextTest, SymbolTableSetterWithManualLSTInProgressFails) {
 
     ION_ASSERT_OK(ion_writer_close(writer));
     ION_ASSERT_OK(ion_symbol_table_close(symbol_table));
+    ION_ASSERT_OK(ion_stream_close(stream));
 }
 
 TEST(IonSymbolTable, TextWritingKnownSymbolFromSIDResolvesText) {
@@ -718,6 +724,9 @@ TEST(IonSymbolTable, TextWritingKnownSymbolFromSIDResolvesText) {
 
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, stream, &result, &bytes_flushed));
     assertStringsEqual("$ion_symbol_table::{imports:[{name:\"import1\",version:1,max_id:1},{name:\"import2\",version:1,max_id:2}]} {sym1:sym2::sym3}", (char *)result, bytes_flushed);
+    free(result);
+
+    ion_catalog_close(catalog);
 }
 
 TEST(IonSymbolTable, TextWritingSymbolWithUnknownTextAsSidFromImportWritesIdentifierAndForcesSymbolTable) {
@@ -747,6 +756,7 @@ TEST(IonSymbolTable, TextWritingSymbolWithUnknownTextAsSidFromImportWritesIdenti
 
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, stream, &result, &bytes_flushed));
     assertStringsEqual("$ion_symbol_table::{imports:[{name:\"foo\",version:1,max_id:3}]} abc $11 def", (char *)result, bytes_flushed);
+    ion_symbol_table_close(import);
     free(result);
 }
 
@@ -803,6 +813,7 @@ TEST_P(BinaryAndTextTest, WritingSymbolTokensWithUnknownTextFromImport) {
         ION_SYMBOL_TEST_REWRITE_WITH_CATALOG_FROM_WRITER_AND_ASSERT_TEXT("$ion_symbol_table::{imports:[{name:\"foo\",version:1,max_id:3}]} {abc:$11::def}");
     }
     ION_ASSERT_OK(ion_writer_options_close_shared_imports(&writer_options));
+    ION_ASSERT_OK(ion_symbol_table_close(import));
 }
 
 TEST_P(BinaryAndTextTest, WritingSymbolTokensWithUnknownTextFromCatalog) {
@@ -843,6 +854,7 @@ TEST_P(BinaryAndTextTest, WritingSymbolTokensWithUnknownTextFromCatalog) {
     else {
         ION_SYMBOL_TEST_REWRITE_WITH_CATALOG_FROM_WRITER_AND_ASSERT_TEXT("{sym1:sym2::sym3}");
     }
+    ION_ASSERT_OK(ion_catalog_close(catalog));
 }
 
 TEST_P(BinaryAndTextTest, WritingInvalidIonSymbolFails) {
@@ -863,6 +875,7 @@ TEST_P(BinaryAndTextTest, WritingInvalidIonSymbolFails) {
     ASSERT_EQ(IERR_INVALID_SYMBOL, ion_writer_write_field_name_symbol(writer, &symbol));
     ION_ASSERT_OK(ion_writer_finish_container(writer));
     ION_ASSERT_OK(ion_writer_close(writer));
+    ION_ASSERT_OK(ion_stream_close(stream));
 }
 
 TEST_P(BinaryAndTextTest, WritingIonSymbolWithUnknownTextNotFoundInImportsOrCatalogFails) {
@@ -896,6 +909,10 @@ TEST_P(BinaryAndTextTest, WritingIonSymbolWithUnknownTextNotFoundInImportsOrCata
     ION_ASSERT_OK(ion_writer_finish_container(writer));
     ION_ASSERT_OK(ion_writer_close(writer));
     ION_ASSERT_OK(ion_writer_options_close_shared_imports(&writer_options));
+    //ION_ASSERT_OK(ion_catalog_release_symbol_table(catalog, import));
+    ION_ASSERT_OK(ion_symbol_table_close(import));
+    ION_ASSERT_OK(ion_catalog_close(catalog));
+    ION_ASSERT_OK(ion_stream_close(stream));
 }
 
 TEST(IonSymbolTable, TextWritingSymbolWithUnknownTextFromManuallyWrittenSymbolTableWritesIdentifierAndForcesSymbolTable) {
@@ -1058,6 +1075,8 @@ TEST_P(BinaryAndTextTest, FlushingOrFinishingOrClosingWriterBelowTopLevelFails)
     ASSERT_EQ(IERR_UNEXPECTED_EOF, ion_writer_finish(writer, &bytes_flushed));
     ASSERT_EQ(0, bytes_flushed);
     ASSERT_EQ(IERR_UNEXPECTED_EOF, ion_writer_close(writer));
+
+    ION_ASSERT_OK(ion_stream_close(stream));
 }
 
 TEST_P(BinaryAndTextTest, ClosingWriterWithPendingLobFails) {
@@ -1065,12 +1084,15 @@ TEST_P(BinaryAndTextTest, ClosingWriterWithPendingLobFails) {
     bytes_flushed = 0;
 
     ION_ASSERT_OK(ion_test_new_writer(&writer, &stream, is_binary));
+    printf("1. Stream = %p\n", stream);
     ION_ASSERT_OK(ion_writer_start_lob(writer, tid_CLOB));
     ASSERT_EQ(IERR_UNEXPECTED_EOF, ion_writer_flush(writer, &bytes_flushed));
     ASSERT_EQ(0, bytes_flushed);
     ASSERT_EQ(IERR_UNEXPECTED_EOF, ion_writer_finish(writer, &bytes_flushed));
     ASSERT_EQ(0, bytes_flushed);
     ASSERT_EQ(IERR_UNEXPECTED_EOF, ion_writer_close(writer));
+    printf("2. Stream = %p\n", stream);
+    ION_ASSERT_OK(ion_stream_close(stream));
 }
 
 TEST(IonSymbolTable, LoadSymbolTableWithAnnotationSecondFails) {
@@ -1440,6 +1462,7 @@ TEST_P(BinaryAndTextTest, WriterAcceptsImportsAfterConstruction) {
     ION_ASSERT_OK(ion_writer_close(writer));
     ION_ASSERT_OK(ion_catalog_close(catalog));
     ION_ASSERT_OK(ion_writer_options_close_shared_imports(&writer_options));
+    ION_ASSERT_OK(ion_stream_close(stream));
 }
 
 TEST_P(BinaryAndTextTest, AddImportedTablesFailsBelowTopLevel) {
@@ -1623,6 +1646,7 @@ TEST_P(BinaryAndTextTest, AddImportedTablesFailsWithPendingAnnotations) {
     ION_ASSERT_OK(ion_writer_add_annotation(writer, &foo));
     ASSERT_EQ(IERR_INVALID_STATE, ion_writer_add_imported_tables(writer, &new_imports));
     ION_ASSERT_OK(ion_writer_close(writer));
+    ION_ASSERT_OK(ion_stream_close(stream));
 }
 
 TEST_P(BinaryAndTextTest, LSTNullSlotsRoundtrippedAsSymbolZero) {
@@ -1682,6 +1706,8 @@ TEST_P(BinaryAndTextTest, ReaderSkipsOverSymbol) {
     assertStringsEqual((char *)def_written.value, (char *)def_read.value, def_written.length);
     ION_ASSERT_OK(ion_reader_next(reader, &type));
     ASSERT_EQ(tid_EOF, type);
+    ION_ASSERT_OK(ion_reader_close(reader));
+    free(data);
 }
 
 TEST_P(BinaryAndTextTest, ReaderSkipsOverIVMBoundary) {
@@ -1714,6 +1740,8 @@ TEST_P(BinaryAndTextTest, ReaderSkipsOverIVMBoundary) {
     assertStringsEqual((char *)def_written.value, (char *)def_read.value, def_written.length);
     ION_ASSERT_OK(ion_reader_next(reader, &type));
     ASSERT_EQ(tid_EOF, type);
+    ION_ASSERT_OK(ion_reader_close(reader));
+    free(data);
 }
 
 TEST(IonSymbolTable, CanBeRemovedFromCatalog) {
@@ -1734,4 +1762,6 @@ TEST(IonSymbolTable, CanBeRemovedFromCatalog) {
     ION_ASSERT_OK(ion_catalog_release_symbol_table(catalog, import2));
     ION_ASSERT_OK(ion_catalog_get_symbol_table_count(catalog, &cnt));
     ASSERT_EQ(0, cnt);
+
+    ION_ASSERT_OK(ion_catalog_close(catalog));
 }
diff --git a/test/test_ion_text.cpp b/test/test_ion_text.cpp
index 04c0998..df16373 100644
--- a/test/test_ion_text.cpp
+++ b/test/test_ion_text.cpp
@@ -59,6 +59,8 @@ TEST(IonTextSexp, ReaderHandlesNested)
     ASSERT_EQ(tid_EOF, type);
 
     ION_ASSERT_OK(ion_reader_close(reader));
+    free(third);
+    free(fourth);
 }
 
 TEST(IonTextTimestamp, WriterIgnoresSuperfluousOffset) {
@@ -77,6 +79,8 @@ TEST(IonTextTimestamp, WriterIgnoresSuperfluousOffset) {
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, ion_stream, &result, &result_len));
 
     assertStringsEqual("0001T", (char *)result, result_len);
+
+    free(result);
 }
 
 TEST(IonTextSymbol, WriterWritesSymbolValueZero) {
@@ -94,6 +98,8 @@ TEST(IonTextSymbol, WriterWritesSymbolValueZero) {
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, ion_stream, &result, &result_len));
 
     assertStringsEqual("$0 '$0'", (char *)result, result_len);
+
+    free(result);
 }
 
 TEST(IonTextSymbol, WriterWritesSymbolAnnotationZero) {
@@ -117,6 +123,7 @@ TEST(IonTextSymbol, WriterWritesSymbolAnnotationZero) {
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, ion_stream, &result, &result_len));
 
     assertStringsEqual("'$0'::$0 $0::$0::'$0'", (char *)result, result_len);
+    free(result);
 }
 
 TEST(IonTextSymbol, WriterWritesSymbolFieldNameZero) {
@@ -151,6 +158,8 @@ TEST(IonTextSymbol, WriterWritesSymbolFieldNameZero) {
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, ion_stream, &result, &result_len));
 
     assertStringsEqual("{'$0':'$0'::$0,$0:'$0'::$0,'$0':$0::$0,$0:$0::$0}", (char *)result, result_len);
+
+    free(result);
 }
 
 TEST(IonTextSymbol, ReaderReadsSymbolValueSymbolZero) {
@@ -184,6 +193,7 @@ TEST(IonTextSymbol, ReaderReadsAnnotationSymbolZero) {
     ION_STRING annotation_strs[1];
     SIZE num_annotations;
     ION_SYMBOL symbol;
+    char *tmp = NULL;
 
     ION_ASSERT_OK(ion_test_new_text_reader(ion_text, &reader));
 
@@ -191,7 +201,7 @@ TEST(IonTextSymbol, ReaderReadsAnnotationSymbolZero) {
     ASSERT_EQ(tid_SYMBOL, type);
     ION_ASSERT_OK(ion_reader_get_annotations(reader, annotation_strs, 1, &num_annotations));
     ASSERT_EQ(1, num_annotations);
-    ASSERT_STREQ("$0", ion_string_strdup(&annotation_strs[0]));
+    ASSERT_STREQ("$0", tmp = ion_string_strdup(&annotation_strs[0])); free(tmp);
     ION_ASSERT_OK(ion_test_reader_read_symbol_sid(reader, &symbol_value));
     ASSERT_EQ(0, symbol_value);
 
@@ -226,13 +236,14 @@ TEST(IonTextSymbol, ReaderReadsFieldNameSymbolZero) {
     ASSERT_EQ(tid_STRUCT, type);
     ION_ASSERT_OK(ion_reader_step_in(reader));
 
+    char *tmp = NULL;
     ION_ASSERT_OK(ion_reader_next(reader, &type));
     ASSERT_EQ(tid_SYMBOL, type);
     ION_ASSERT_OK(ion_reader_get_field_name(reader, &field_name_str));
-    ASSERT_STREQ("$0", ion_string_strdup(&field_name_str)); // This one just looks like symbol zero, but it's actually a user symbol with the text $0
+    ASSERT_STREQ("$0", tmp = ion_string_strdup(&field_name_str)); free(tmp); // This one just looks like symbol zero, but it's actually a user symbol with the text $0
     ION_ASSERT_OK(ion_reader_get_annotations(reader, annotations, 1, &num_annotations));
     ASSERT_EQ(1, num_annotations);
-    ASSERT_STREQ("$0", ion_string_strdup(&annotations[0]));
+    ASSERT_STREQ("$0", tmp = ion_string_strdup(&annotations[0])); free(tmp);
     ION_ASSERT_OK(ion_test_reader_read_symbol_sid(reader, &symbol_value));
     ASSERT_EQ(0, symbol_value);
 
@@ -246,7 +257,7 @@ TEST(IonTextSymbol, ReaderReadsFieldNameSymbolZero) {
     ASSERT_EQ(1, num_annotations);
     ASSERT_EQ(0, annotation_symbols[0].sid);
     ION_ASSERT_OK(ion_reader_read_string(reader, &symbol_text));
-    ASSERT_STREQ("$0", ion_string_strdup(&symbol_text));
+    ASSERT_STREQ("$0", tmp = ion_string_strdup(&symbol_text)); free(tmp);
 
     ION_ASSERT_OK(ion_reader_next(reader, &type));
     ASSERT_EQ(tid_SYMBOL, type);
@@ -256,7 +267,7 @@ TEST(IonTextSymbol, ReaderReadsFieldNameSymbolZero) {
     ASSERT_EQ(0, field_name->sid); // Because it was unquoted, this represents symbol zero.
     ION_ASSERT_OK(ion_reader_get_annotations(reader, annotations, 1, &num_annotations));
     ASSERT_EQ(1, num_annotations);
-    ASSERT_STREQ("$0", ion_string_strdup(&annotations[0]));
+    ASSERT_STREQ("$0", tmp = ion_string_strdup(&annotations[0])); free(tmp);
     ION_ASSERT_OK(ion_test_reader_read_symbol_sid(reader, &symbol_value));
     ASSERT_EQ(0, symbol_value);
 
@@ -295,21 +306,35 @@ TEST(IonTextSymbol, WriterWriteAllValuesPreservesSymbolZero) {
     const BYTE *ion_binary = (BYTE *)"\xDE\x90\x8A\xE3\x81\x8A\x70\x80\xE4\x81\x80\x71\x0A\x80\xE3\x81\x8A\x70";
     const SIZE ion_binary_size = 18;
 
-    BYTE *result = NULL;
-    SIZE result_len;
+    // Storage and length to receive text encoding.
+    BYTE *as_text = NULL;
+    SIZE as_text_len = 0;
 
-    ion_test_write_all_values_from_text(ion_text, &result, &result_len, FALSE);
-    assertStringsEqual(ion_text, (char *)result, result_len);
+    ion_test_write_all_values_from_text(ion_text, &as_text, &as_text_len, FALSE);
+    assertStringsEqual(ion_text, (char *)as_text, as_text_len);
+    free(as_text); as_text = NULL;
 
-    ion_test_write_all_values_from_text(ion_text, &result, &result_len, TRUE);
-    assertBytesEqual((const char *)ion_binary, ion_binary_size, result + result_len - ion_binary_size, ion_binary_size);
+    // Storage and length to receive binary encoding.
+    BYTE *as_binary = NULL;
+    SIZE as_binary_len = 0;
 
-    ion_test_write_all_values_from_binary(result, result_len, &result, &result_len, FALSE);
-    assertStringsEqual(ion_text, (char *)result, result_len);
+    ion_test_write_all_values_from_text(ion_text, &as_binary, &as_binary_len, TRUE);
+    assertBytesEqual((const char *)ion_binary, ion_binary_size, as_binary + as_binary_len - ion_binary_size, ion_binary_size);
 
-    ion_test_write_all_values_from_text(ion_text, &result, &result_len, TRUE);
-    ion_test_write_all_values_from_binary(result, result_len, &result, &result_len, TRUE);
-    assertBytesEqual((const char *)ion_binary, ion_binary_size, result + result_len - ion_binary_size, ion_binary_size);
+    ion_test_write_all_values_from_binary(as_binary, as_binary_len, &as_text, &as_text_len, FALSE);
+    assertStringsEqual(ion_text, (char *)as_text, as_text_len);
+    free(as_text); as_text = NULL;
+    free(as_binary); as_binary = NULL;
+
+    // Storage and length for final binary round-trip
+    BYTE *bin_rt = NULL;
+    SIZE bin_rt_len = 0;
+    ion_test_write_all_values_from_text(ion_text, &as_binary, &as_binary_len, TRUE);
+    ion_test_write_all_values_from_binary(as_binary, as_binary_len, &bin_rt, &bin_rt_len, TRUE);
+    assertBytesEqual((const char *)ion_binary, ion_binary_size, bin_rt + bin_rt_len - ion_binary_size, ion_binary_size);
+
+    free(bin_rt);
+    free(as_binary);
 }
 
 TEST(IonTextSymbol, WriterWritesSymbolValueIVMTextAsNoOp) {
@@ -331,6 +356,8 @@ TEST(IonTextSymbol, WriterWritesSymbolValueIVMTextAsNoOp) {
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, ion_stream, &result, &result_len));
 
     assertStringsEqual("123 456 789", (char *)result, result_len);
+
+    free(result);
 }
 
 TEST(IonTextSymbol, ReaderReadsSymbolValueIVM) {
@@ -430,6 +457,7 @@ TEST(IonTextSymbol, WriterWritesKeywordsAsQuotedSymbols) {
     ION_ASSERT_OK(ion_test_writer_get_bytes(writer, ion_stream, &result, &result_len));
 
     assertStringsEqual("'false' 'true' 'nan'", (char *)result, result_len);
+    free(result);
 }
 
 TEST(IonTextSymbol, ReaderChoosesLowestSIDForDuplicateSymbol) {
@@ -472,21 +500,32 @@ TEST(IonTextSymbol, WriterWriteAllValuesPreservesSymbolKeywords) {
     const BYTE *ion_binary = (BYTE *)"\xD6\x8B\xE4\x81\x8C\x71\x0A";
     const SIZE ion_binary_size = 7;
 
-    BYTE *result = NULL;
-    SIZE result_len;
+    BYTE *as_text = NULL;
+    SIZE as_text_len = 0;
 
-    ion_test_write_all_values_from_text(ion_text, &result, &result_len, FALSE);
-    assertStringsEqual(ion_text, (char *)result, result_len);
+    ion_test_write_all_values_from_text(ion_text, &as_text, &as_text_len, FALSE);
+    assertStringsEqual(ion_text, (char *)as_text, as_text_len);
+    free(as_text); as_text = NULL;
 
-    ion_test_write_all_values_from_text(ion_text, &result, &result_len, TRUE);
-    assertBytesEqual((const char *)ion_binary, ion_binary_size, result + result_len - ion_binary_size, ion_binary_size);
+    BYTE *as_bin = NULL;
+    SIZE as_bin_len = 0;
 
-    ion_test_write_all_values_from_binary(result, result_len, &result, &result_len, FALSE);
-    assertStringsEqual(ion_text, (char *)result, result_len);
+    ion_test_write_all_values_from_text(ion_text, &as_bin, &as_bin_len, TRUE);
+    assertBytesEqual((const char *)ion_binary, ion_binary_size, as_bin + as_bin_len - ion_binary_size, ion_binary_size);
 
-    ion_test_write_all_values_from_text(ion_text, &result, &result_len, TRUE);
-    ion_test_write_all_values_from_binary(result, result_len, &result, &result_len, TRUE);
-    assertBytesEqual((const char *)ion_binary, ion_binary_size, result + result_len - ion_binary_size, ion_binary_size);
+    ion_test_write_all_values_from_binary(as_bin, as_bin_len, &as_text, &as_text_len, FALSE);
+    assertStringsEqual(ion_text, (char *)as_text, as_text_len);
+    free(as_bin);
+    free(as_text);
+
+    BYTE *final_bin = NULL;
+    SIZE final_bin_len = 0;
+    ion_test_write_all_values_from_text(ion_text, &as_bin, &as_bin_len, TRUE);
+    ion_test_write_all_values_from_binary(as_bin, as_bin_len, &final_bin, &final_bin_len, TRUE);
+    assertBytesEqual((const char *)ion_binary, ion_binary_size, final_bin + final_bin_len - ion_binary_size, ion_binary_size);
+
+    free(as_bin);
+    free(final_bin);
 }
 
 TEST(IonTextSymbol, ReaderReadsUndefinedSymbol) {
@@ -720,6 +759,7 @@ TEST(IonTextReader, UnpositionedReaderHasTypeNone) {
     ION_ASSERT_OK(ion_test_new_text_reader(ion_text, &reader));
     ION_ASSERT_OK(ion_reader_get_type(reader, &type));
     ASSERT_EQ(tid_none, type);
+    ION_ASSERT_OK(ion_reader_close(reader));
 }
 
 TEST(IonTextStruct, FailsOnFieldNameWithNoValueAtStructEnd) {
@@ -731,6 +771,7 @@ TEST(IonTextStruct, FailsOnFieldNameWithNoValueAtStructEnd) {
     ASSERT_EQ(tid_STRUCT, type);
     ION_ASSERT_OK(ion_reader_step_in(reader));
     ASSERT_EQ(IERR_INVALID_SYNTAX, ion_reader_next(reader, &type));
+    ION_ASSERT_OK(ion_reader_close(reader));
 }
 
 TEST(IonTextStruct, FailsOnFieldNameWithNoValueInMiddle) {
@@ -743,6 +784,7 @@ TEST(IonTextStruct, FailsOnFieldNameWithNoValueInMiddle) {
     ION_ASSERT_OK(ion_reader_step_in(reader));
     ION_ASSERT_OK(ion_reader_next(reader, &type));
     ASSERT_EQ(IERR_INVALID_SYNTAX, ion_reader_next(reader, &type));
+    ION_ASSERT_OK(ion_reader_close(reader));
 }
 
 // reproduction for amzn/ion-c#235
@@ -757,6 +799,7 @@ TEST(IonTextInt, BinaryLiterals) {
     ASSERT_EQ(tid_INT, type);
     ION_ASSERT_OK(ion_reader_read_int64(reader, &value));
     ASSERT_EQ(-4, value);
+    ION_ASSERT_OK(ion_reader_close(reader));
 }
 
 TEST(IonTextTimestamp, InvalidTimestamp) {
@@ -769,4 +812,5 @@ TEST(IonTextTimestamp, InvalidTimestamp) {
     ION_ASSERT_OK(ion_reader_next(reader, &type));
     ASSERT_EQ(tid_TIMESTAMP, type);
     ASSERT_EQ( IERR_INVALID_TIMESTAMP, ion_reader_read_timestamp(reader, &value));
+    ION_ASSERT_OK(ion_reader_close(reader));
 }
diff --git a/test/test_ion_timestamp.cpp b/test/test_ion_timestamp.cpp
index 3f4f411..0cd1a0e 100644
--- a/test/test_ion_timestamp.cpp
+++ b/test/test_ion_timestamp.cpp
@@ -181,5 +181,6 @@ TEST_P(IonTimestampOutOfRangeFraction, WriterFailsOnOutOfRangeFraction) {
 
     ION_ASSERT_OK(ion_test_new_writer(&writer, &stream, true));
     ASSERT_EQ(IERR_INVALID_TIMESTAMP, ion_writer_write_timestamp(writer, &timestamp));
-
+    ION_ASSERT_OK(ion_writer_close(writer));
+    ION_ASSERT_OK(ion_stream_close(stream));
 }
diff --git a/test/test_ion_values.cpp b/test/test_ion_values.cpp
index 5285589..180dfc4 100644
--- a/test/test_ion_values.cpp
+++ b/test/test_ion_values.cpp
@@ -46,7 +46,7 @@ TEST(IonUserStream, SucceedsInTheMiddleOfAValue) {
     hREADER reader;
     ION_TYPE type;
     ION_STRING value;
-    ION_ASSERT_OK(ion_stream_open_handler_in(&test_stream_handler, &chunk1_stream, &ion_stream));
+    ION_ASSERT_OK(ion_stream_open_handler_in(test_stream_handler, &chunk1_stream, &ion_stream));
     ION_ASSERT_OK(ion_reader_open(&reader, ion_stream, NULL));
     ION_ASSERT_OK(ion_reader_next(reader, &type));
     ASSERT_EQ(tid_STRUCT, type);
@@ -60,4 +60,5 @@ TEST(IonUserStream, SucceedsInTheMiddleOfAValue) {
     ION_ASSERT_OK(ion_reader_step_out(reader));
 
     ION_ASSERT_OK(ion_reader_close(reader));
+    ION_ASSERT_OK(ion_stream_close(ion_stream));
 }
diff --git a/test/test_ion_writer.cpp b/test/test_ion_writer.cpp
index 4bd5b86..128ba5e 100644
--- a/test/test_ion_writer.cpp
+++ b/test/test_ion_writer.cpp
@@ -32,7 +32,7 @@ class WriterTest : public ::testing::Test {
     FILE *out;
 };
 
-iERR ion_test_open_file_writer(hWRITER *writer, FILE *out, BOOL is_binary) {
+iERR ion_test_open_file_writer(hWRITER *writer, FILE *out, BOOL is_binary, ION_STREAM **stream) {
     iENTER;
     ION_WRITER_OPTIONS options;
     ION_STREAM *ion_stream = NULL;
@@ -43,6 +43,8 @@ iERR ion_test_open_file_writer(hWRITER *writer, FILE *out, BOOL is_binary) {
     IONCHECK(ion_stream_open_file_out(out, &ion_stream));
     IONCHECK(ion_writer_open(writer, ion_stream, &options));
 
+    *stream = ion_stream;
+
     iRETURN;
 }
 
@@ -65,15 +67,18 @@ TEST_F(WriterTest, ResourcesNotLeakedOnWriteToTooSmallBuffer)
 
 TEST_F(WriterTest, BinaryWriterCloseMustFlushStream) {
     hWRITER writer = NULL;
+    ION_STREAM *stream = NULL;
 
     long file_size;
 
-    ion_test_open_file_writer(&writer, out, TRUE);
+    ion_test_open_file_writer(&writer, out, TRUE, &stream);
 
     ION_ASSERT_OK(ion_writer_write_bool(writer, TRUE));
 
     ION_ASSERT_OK(ion_writer_close(writer));
 
+    ION_ASSERT_OK(ion_stream_close(stream));
+
     // get the size of the file after closing the writer
     fseek(out, 0L, SEEK_END);
     file_size = ftell(out);
@@ -84,14 +89,16 @@ TEST_F(WriterTest, BinaryWriterCloseMustFlushStream) {
 
 TEST_F(WriterTest, TextWriterCloseMustFlushStream) {
     hWRITER writer = NULL;
+    ION_STREAM *stream = NULL;
 
     long file_size;
 
-    ion_test_open_file_writer(&writer, out, FALSE);
+    ion_test_open_file_writer(&writer, out, FALSE, &stream);
 
     ION_ASSERT_OK(ion_writer_write_bool(writer, TRUE));
 
     ION_ASSERT_OK(ion_writer_close(writer));
+    ION_ASSERT_OK(ion_stream_close(stream));
 
     // get the size of the file after closing the writer
     fseek(out, 0L, SEEK_END);