Merge branch 'dev' into dev-0.12

tests/conversion/conversion.c

@@ -1,6 +1,385 @@
 
-#include "../test_common/ma_test_common.c"
+#include "../common/common.c"
-#include "ma_test_automated_data_converter.c"
+
+ma_result init_data_converter(ma_uint32 rateIn, ma_uint32 rateOut, ma_resample_algorithm algorithm, ma_data_converter* pDataConverter)
+{
+    ma_result result;
+    ma_data_converter_config config;
+
+    config = ma_data_converter_config_init(ma_format_s16, ma_format_s16, 1, 1, rateIn, rateOut);
+    config.resampling.algorithm = algorithm;
+
+    result = ma_data_converter_init(&config, NULL, pDataConverter);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+#if 0
+ma_result test_data_converter__passthrough()
+{
+    /*
+    Notes:
+      - The isPassthrough flag should be set to true. Both the positive and negative cases need to be tested.
+      - ma_data_converter_set_rate() should fail with MA_INVALID_OPERATION.
+      - The output should be identical to the input.
+    */
+    printf("Passthrough\n");
+
+    
+
+    return MA_SUCCESS;
+}
+#endif
+
+ma_result test_data_converter__resampling_expected_output_fixed_interval(ma_data_converter* pDataConverter, ma_uint64 frameCountPerIteration)
+{
+    ma_result result = MA_SUCCESS;
+    ma_int16 input[4096];
+    ma_int16 i;
+
+    MA_ASSERT(frameCountPerIteration < ma_countof(input));
+
+    /* Fill the input buffer with sequential numbers so we can get an idea on the state of things. Useful for inspecting the linear backend in particular. */
+    for (i = 0; i < (ma_int16)ma_countof(input); i += 1) {
+        input[i] = i;
+    }
+
+    for (i = 0; i < (ma_int16)ma_countof(input); i += (ma_int16)frameCountPerIteration) {
+        ma_int16 output[4096];
+        ma_uint64 outputFrameCount;
+        ma_uint64 inputFrameCount;
+        ma_uint64 expectedOutputFrameCount;
+
+        /* We retrieve the required number of input frames for the specified number of output frames, and then compare with what we actually get when reading. */
+        ma_data_converter_get_expected_output_frame_count(pDataConverter, frameCountPerIteration, &expectedOutputFrameCount);
+
+        outputFrameCount = ma_countof(output);
+        inputFrameCount = frameCountPerIteration;
+        result = ma_data_converter_process_pcm_frames(pDataConverter, input, &inputFrameCount, output, &outputFrameCount);
+        if (result != MA_SUCCESS) {
+            printf("Failed to process frames.");
+            break;
+        }
+
+        if (outputFrameCount != expectedOutputFrameCount) {
+            printf("ERROR: Predicted vs actual output count mismatch: predicted=%d, actual=%d\n", (int)expectedOutputFrameCount, (int)outputFrameCount);
+            result = MA_ERROR;
+        }
+    }
+
+    if (result != MA_SUCCESS) {
+        printf("FAILED\n");
+    } else {
+        printf("PASSED\n");
+    }
+
+    return result;
+}
+
+ma_result test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(ma_resample_algorithm algorithm, ma_uint32 rateIn, ma_uint32 rateOut, ma_uint64 frameCountPerIteration)
+{
+    ma_result result;
+    ma_bool32 hasError = MA_FALSE;
+    ma_data_converter converter;
+
+    result = init_data_converter(rateIn, rateOut, algorithm, &converter);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_expected_output_fixed_interval(&converter, frameCountPerIteration);
+
+    ma_data_converter_uninit(&converter, NULL);
+
+    if (hasError) {
+        return MA_ERROR;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+ma_result test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(ma_resample_algorithm algorithm, ma_uint64 frameCountPerIteration)
+{
+    ma_result result;
+    ma_bool32 hasError = MA_FALSE;
+
+    result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 48000, frameCountPerIteration);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 48000, 44100, frameCountPerIteration);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    
+    result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 192000, frameCountPerIteration);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 192000, 44100, frameCountPerIteration);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    if (hasError) {
+        return MA_ERROR;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+ma_result test_data_converter__resampling_expected_output_by_algorithm(ma_resample_algorithm algorithm)
+{
+    ma_result result;
+    ma_bool32 hasError = MA_FALSE;
+
+    result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 1);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 16);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 127);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+    
+    if (hasError) {
+        return MA_ERROR;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+ma_result test_data_converter__resampling_expected_output(void)
+{
+    ma_result result;
+    ma_bool32 hasError = MA_FALSE;
+
+    printf("Linear\n");
+    result = test_data_converter__resampling_expected_output_by_algorithm(ma_resample_algorithm_linear);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    if (hasError) {
+        return MA_ERROR;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+
+ma_result test_data_converter__resampling_required_input_fixed_interval(ma_data_converter* pDataConverter, ma_uint64 frameCountPerIteration)
+{
+    ma_result result = MA_SUCCESS;
+    ma_int16 input[4096];
+    ma_int16 i;
+
+    MA_ASSERT(frameCountPerIteration < ma_countof(input));
+
+    /* Fill the input buffer with sequential numbers so we can get an idea on the state of things. Useful for inspecting the linear backend in particular. */
+    for (i = 0; i < (ma_int16)ma_countof(input); i += 1) {
+        input[i] = i;
+    }
+
+    for (i = 0; i < (ma_int16)ma_countof(input); i += (ma_int16)frameCountPerIteration) {
+        ma_int16 output[4096];
+        ma_uint64 outputFrameCount;
+        ma_uint64 inputFrameCount;
+        ma_uint64 requiredInputFrameCount;
+
+        /* We retrieve the required number of input frames for the specified number of output frames, and then compare with what we actually get when reading. */
+        ma_data_converter_get_required_input_frame_count(pDataConverter, frameCountPerIteration, &requiredInputFrameCount);
+
+        outputFrameCount = frameCountPerIteration;
+        inputFrameCount = ma_countof(input);
+        result = ma_data_converter_process_pcm_frames(pDataConverter, input, &inputFrameCount, output, &outputFrameCount);
+        if (result != MA_SUCCESS) {
+            printf("Failed to process frames.");
+            break;
+        }
+
+        if (inputFrameCount != requiredInputFrameCount) {
+            printf("ERROR: Predicted vs actual input count mismatch: predicted=%d, actual=%d\n", (int)requiredInputFrameCount, (int)inputFrameCount);
+            result = MA_ERROR;
+        }
+    }
+
+    if (result != MA_SUCCESS) {
+        printf("FAILED\n");
+    } else {
+        printf("PASSED\n");
+    }
+
+    return result;
+}
+
+ma_result test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(ma_resample_algorithm algorithm, ma_uint32 rateIn, ma_uint32 rateOut, ma_uint64 frameCountPerIteration)
+{
+    ma_result result;
+    ma_bool32 hasError = MA_FALSE;
+    ma_data_converter converter;
+
+    result = init_data_converter(rateIn, rateOut, algorithm, &converter);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_required_input_fixed_interval(&converter, frameCountPerIteration);
+
+    ma_data_converter_uninit(&converter, NULL);
+
+    if (hasError) {
+        return MA_ERROR;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+ma_result test_data_converter__resampling_required_input_by_algorithm_fixed_interval(ma_resample_algorithm algorithm, ma_uint64 frameCountPerIteration)
+{
+    ma_result result;
+    ma_bool32 hasError = MA_FALSE;
+
+    result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 48000, frameCountPerIteration);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 48000, 44100, frameCountPerIteration);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    
+    result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 192000, frameCountPerIteration);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 192000, 44100, frameCountPerIteration);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    if (hasError) {
+        return MA_ERROR;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+ma_result test_data_converter__resampling_required_input_by_algorithm(ma_resample_algorithm algorithm)
+{
+    ma_result result;
+    ma_bool32 hasError = MA_FALSE;
+
+    result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 1);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 16);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 127);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+    
+    if (hasError) {
+        return MA_ERROR;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+ma_result test_data_converter__resampling_required_input(void)
+{
+    ma_result result;
+    ma_bool32 hasError = MA_FALSE;
+
+    printf("Linear\n");
+    result = test_data_converter__resampling_required_input_by_algorithm(ma_resample_algorithm_linear);
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    if (hasError) {
+        return MA_ERROR;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+
+
+
+ma_result test_data_converter__resampling(void)
+{
+    ma_result result;
+    ma_bool32 hasError = MA_FALSE;
+
+    result = test_data_converter__resampling_expected_output();
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    result = test_data_converter__resampling_required_input();
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+    if (hasError) {
+        return MA_ERROR;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+
+int test_entry__data_converter(int argc, char** argv)
+{
+    ma_result result;
+    ma_bool32 hasError = MA_FALSE;
+
+    (void)argc;
+    (void)argv;
+
+#if 0
+    result = test_data_converter__passthrough();
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+#endif
+
+    result = test_data_converter__resampling();
+    if (result != MA_SUCCESS) {
+        hasError = MA_TRUE;
+    }
+
+
+    if (hasError) {
+        return -1;
+    } else {
+        return 0;
+    }
+}
+
+
 
 int main(int argc, char** argv)
 {

tests/conversion/ma_test_automated_data_converter.c

@@ -1,379 +0,0 @@
-
-ma_result init_data_converter(ma_uint32 rateIn, ma_uint32 rateOut, ma_resample_algorithm algorithm, ma_data_converter* pDataConverter)
-{
-    ma_result result;
-    ma_data_converter_config config;
-
-    config = ma_data_converter_config_init(ma_format_s16, ma_format_s16, 1, 1, rateIn, rateOut);
-    config.resampling.algorithm = algorithm;
-
-    result = ma_data_converter_init(&config, NULL, pDataConverter);
-    if (result != MA_SUCCESS) {
-        return result;
-    }
-
-    return MA_SUCCESS;
-}
-
-#if 0
-ma_result test_data_converter__passthrough()
-{
-    /*
-    Notes:
-      - The isPassthrough flag should be set to true. Both the positive and negative cases need to be tested.
-      - ma_data_converter_set_rate() should fail with MA_INVALID_OPERATION.
-      - The output should be identical to the input.
-    */
-    printf("Passthrough\n");
-
-    
-
-    return MA_SUCCESS;
-}
-#endif
-
-ma_result test_data_converter__resampling_expected_output_fixed_interval(ma_data_converter* pDataConverter, ma_uint64 frameCountPerIteration)
-{
-    ma_result result = MA_SUCCESS;
-    ma_int16 input[4096];
-    ma_int16 i;
-
-    MA_ASSERT(frameCountPerIteration < ma_countof(input));
-
-    /* Fill the input buffer with sequential numbers so we can get an idea on the state of things. Useful for inspecting the linear backend in particular. */
-    for (i = 0; i < (ma_int16)ma_countof(input); i += 1) {
-        input[i] = i;
-    }
-
-    for (i = 0; i < (ma_int16)ma_countof(input); i += (ma_int16)frameCountPerIteration) {
-        ma_int16 output[4096];
-        ma_uint64 outputFrameCount;
-        ma_uint64 inputFrameCount;
-        ma_uint64 expectedOutputFrameCount;
-
-        /* We retrieve the required number of input frames for the specified number of output frames, and then compare with what we actually get when reading. */
-        ma_data_converter_get_expected_output_frame_count(pDataConverter, frameCountPerIteration, &expectedOutputFrameCount);
-
-        outputFrameCount = ma_countof(output);
-        inputFrameCount = frameCountPerIteration;
-        result = ma_data_converter_process_pcm_frames(pDataConverter, input, &inputFrameCount, output, &outputFrameCount);
-        if (result != MA_SUCCESS) {
-            printf("Failed to process frames.");
-            break;
-        }
-
-        if (outputFrameCount != expectedOutputFrameCount) {
-            printf("ERROR: Predicted vs actual output count mismatch: predicted=%d, actual=%d\n", (int)expectedOutputFrameCount, (int)outputFrameCount);
-            result = MA_ERROR;
-        }
-    }
-
-    if (result != MA_SUCCESS) {
-        printf("FAILED\n");
-    } else {
-        printf("PASSED\n");
-    }
-
-    return result;
-}
-
-ma_result test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(ma_resample_algorithm algorithm, ma_uint32 rateIn, ma_uint32 rateOut, ma_uint64 frameCountPerIteration)
-{
-    ma_result result;
-    ma_bool32 hasError = MA_FALSE;
-    ma_data_converter converter;
-
-    result = init_data_converter(rateIn, rateOut, algorithm, &converter);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_expected_output_fixed_interval(&converter, frameCountPerIteration);
-
-    ma_data_converter_uninit(&converter, NULL);
-
-    if (hasError) {
-        return MA_ERROR;
-    } else {
-        return MA_SUCCESS;
-    }
-}
-
-ma_result test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(ma_resample_algorithm algorithm, ma_uint64 frameCountPerIteration)
-{
-    ma_result result;
-    ma_bool32 hasError = MA_FALSE;
-
-    result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 48000, frameCountPerIteration);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 48000, 44100, frameCountPerIteration);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    
-    result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 192000, frameCountPerIteration);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 192000, 44100, frameCountPerIteration);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    if (hasError) {
-        return MA_ERROR;
-    } else {
-        return MA_SUCCESS;
-    }
-}
-
-ma_result test_data_converter__resampling_expected_output_by_algorithm(ma_resample_algorithm algorithm)
-{
-    ma_result result;
-    ma_bool32 hasError = MA_FALSE;
-
-    result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 1);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 16);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 127);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-    
-    if (hasError) {
-        return MA_ERROR;
-    } else {
-        return MA_SUCCESS;
-    }
-}
-
-ma_result test_data_converter__resampling_expected_output(void)
-{
-    ma_result result;
-    ma_bool32 hasError = MA_FALSE;
-
-    printf("Linear\n");
-    result = test_data_converter__resampling_expected_output_by_algorithm(ma_resample_algorithm_linear);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    if (hasError) {
-        return MA_ERROR;
-    } else {
-        return MA_SUCCESS;
-    }
-}
-
-
-
-ma_result test_data_converter__resampling_required_input_fixed_interval(ma_data_converter* pDataConverter, ma_uint64 frameCountPerIteration)
-{
-    ma_result result = MA_SUCCESS;
-    ma_int16 input[4096];
-    ma_int16 i;
-
-    MA_ASSERT(frameCountPerIteration < ma_countof(input));
-
-    /* Fill the input buffer with sequential numbers so we can get an idea on the state of things. Useful for inspecting the linear backend in particular. */
-    for (i = 0; i < (ma_int16)ma_countof(input); i += 1) {
-        input[i] = i;
-    }
-
-    for (i = 0; i < (ma_int16)ma_countof(input); i += (ma_int16)frameCountPerIteration) {
-        ma_int16 output[4096];
-        ma_uint64 outputFrameCount;
-        ma_uint64 inputFrameCount;
-        ma_uint64 requiredInputFrameCount;
-
-        /* We retrieve the required number of input frames for the specified number of output frames, and then compare with what we actually get when reading. */
-        ma_data_converter_get_required_input_frame_count(pDataConverter, frameCountPerIteration, &requiredInputFrameCount);
-
-        outputFrameCount = frameCountPerIteration;
-        inputFrameCount = ma_countof(input);
-        result = ma_data_converter_process_pcm_frames(pDataConverter, input, &inputFrameCount, output, &outputFrameCount);
-        if (result != MA_SUCCESS) {
-            printf("Failed to process frames.");
-            break;
-        }
-
-        if (inputFrameCount != requiredInputFrameCount) {
-            printf("ERROR: Predicted vs actual input count mismatch: predicted=%d, actual=%d\n", (int)requiredInputFrameCount, (int)inputFrameCount);
-            result = MA_ERROR;
-        }
-    }
-
-    if (result != MA_SUCCESS) {
-        printf("FAILED\n");
-    } else {
-        printf("PASSED\n");
-    }
-
-    return result;
-}
-
-ma_result test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(ma_resample_algorithm algorithm, ma_uint32 rateIn, ma_uint32 rateOut, ma_uint64 frameCountPerIteration)
-{
-    ma_result result;
-    ma_bool32 hasError = MA_FALSE;
-    ma_data_converter converter;
-
-    result = init_data_converter(rateIn, rateOut, algorithm, &converter);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_required_input_fixed_interval(&converter, frameCountPerIteration);
-
-    ma_data_converter_uninit(&converter, NULL);
-
-    if (hasError) {
-        return MA_ERROR;
-    } else {
-        return MA_SUCCESS;
-    }
-}
-
-ma_result test_data_converter__resampling_required_input_by_algorithm_fixed_interval(ma_resample_algorithm algorithm, ma_uint64 frameCountPerIteration)
-{
-    ma_result result;
-    ma_bool32 hasError = MA_FALSE;
-
-    result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 48000, frameCountPerIteration);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 48000, 44100, frameCountPerIteration);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    
-    result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 192000, frameCountPerIteration);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 192000, 44100, frameCountPerIteration);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    if (hasError) {
-        return MA_ERROR;
-    } else {
-        return MA_SUCCESS;
-    }
-}
-
-ma_result test_data_converter__resampling_required_input_by_algorithm(ma_resample_algorithm algorithm)
-{
-    ma_result result;
-    ma_bool32 hasError = MA_FALSE;
-
-    result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 1);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 16);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 127);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-    
-    if (hasError) {
-        return MA_ERROR;
-    } else {
-        return MA_SUCCESS;
-    }
-}
-
-ma_result test_data_converter__resampling_required_input(void)
-{
-    ma_result result;
-    ma_bool32 hasError = MA_FALSE;
-
-    printf("Linear\n");
-    result = test_data_converter__resampling_required_input_by_algorithm(ma_resample_algorithm_linear);
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    if (hasError) {
-        return MA_ERROR;
-    } else {
-        return MA_SUCCESS;
-    }
-}
-
-
-
-
-ma_result test_data_converter__resampling(void)
-{
-    ma_result result;
-    ma_bool32 hasError = MA_FALSE;
-
-    result = test_data_converter__resampling_expected_output();
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    result = test_data_converter__resampling_required_input();
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-    if (hasError) {
-        return MA_ERROR;
-    } else {
-        return MA_SUCCESS;
-    }
-}
-
-
-int test_entry__data_converter(int argc, char** argv)
-{
-    ma_result result;
-    ma_bool32 hasError = MA_FALSE;
-
-    (void)argc;
-    (void)argv;
-
-#if 0
-    result = test_data_converter__passthrough();
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-#endif
-
-    result = test_data_converter__resampling();
-    if (result != MA_SUCCESS) {
-        hasError = MA_TRUE;
-    }
-
-
-    if (hasError) {
-        return -1;
-    } else {
-        return 0;
-    }
-}

tests/deviceio/deviceio.c

@@ -41,7 +41,7 @@ will receive the captured audio.
 If multiple backends are specified, the priority will be based on the order in which you specify them. If multiple waveform or noise types
 are specified the last one on the command line will have priority.
 */
-#include "../test_common/ma_test_common.c"
+#include "../common/common.c"
 
 #ifndef AUTO_CLOSE_TIME_IN_MILLISECONDS
 #define AUTO_CLOSE_TIME_IN_MILLISECONDS 5000

tests/emscripten/emscripten.c

@@ -1,8 +1,7 @@
 #define MA_DEBUG_OUTPUT
 #define MA_NO_DECODING
 #define MA_NO_ENCODING
-#define MINIAUDIO_IMPLEMENTATION
+#include "../../miniaudio.c"
-#include "../../miniaudio.h"
 
 #include <stdio.h>
 

tests/filtering/filtering.c

@@ -1,4 +1,4 @@
-#include "../test_common/ma_test_common.c"
+#include "../common/common.c"
 
 ma_result filtering_init_decoder_and_encoder(const char* pInputFilePath, const char* pOutputFilePath, ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_decoder* pDecoder, ma_encoder* pEncoder)
 {
@@ -24,14 +24,14 @@ ma_result filtering_init_decoder_and_encoder(const char* pInputFilePath, const c
     return MA_SUCCESS;
 }
 
-#include "ma_test_filtering_dithering.c"
+#include "filtering_dithering.c"
-#include "ma_test_filtering_lpf.c"
+#include "filtering_lpf.c"
-#include "ma_test_filtering_hpf.c"
+#include "filtering_hpf.c"
-#include "ma_test_filtering_bpf.c"
+#include "filtering_bpf.c"
-#include "ma_test_filtering_notch.c"
+#include "filtering_notch.c"
-#include "ma_test_filtering_peak.c"
+#include "filtering_peak.c"
-#include "ma_test_filtering_loshelf.c"
+#include "filtering_loshelf.c"
-#include "ma_test_filtering_hishelf.c"
+#include "filtering_hishelf.c"
 
 int main(int argc, char** argv)
 {

tests/generation/generation.c

@@ -1,8 +1,8 @@
 #define MA_NO_DEVICE_IO
-#include "../test_common/ma_test_common.c"
+#include "../common/common.c"
 
-#include "ma_test_generation_noise.c"
+#include "generation_noise.c"
-#include "ma_test_generation_waveform.c"
+#include "generation_waveform.c"
 
 int main(int argc, char** argv)
 {