#pragma warning disable xUnit1026 // Theory methods should use all of their parameters
        public void JsonLdWriterTests(string inputPath, string contextPath, string expectedOutputPath, bool useNativeTypes, bool useRdfType)
#pragma warning restore xUnit1026 // Theory methods should use all of their parameters
        {
            var nqParser = new NQuadsParser(NQuadsSyntax.Rdf11);
            var input    = new TripleStore();

            nqParser.Load(input, inputPath);
            FixStringLiterals(input);
            var expectedOutputJson = File.ReadAllText(expectedOutputPath);
            var expectedOutput     = JToken.Parse(expectedOutputJson);
            var jsonLdWriter       =
                new JsonLdWriter(new JsonLdWriterOptions {
                UseNativeTypes = useNativeTypes, UseRdfType = useRdfType
            });
            var actualOutput = jsonLdWriter.SerializeStore(input);

            try
            {
                Assert.True(DeepEquals(expectedOutput, actualOutput, true, true),
                            $"Test failed for input {Path.GetFileName(inputPath)}\nExpected:\n{expectedOutput}\nActual:\n{actualOutput}");
            }
            catch (DeepEqualityFailure ex)
            {
                Assert.True(false,
                            $"Test failed for input {Path.GetFileName(inputPath)}\nExpected:\n{expectedOutput}\nActual:\n{actualOutput}\nMatch Failured: {ex}");
            }
        }
#pragma warning disable xUnit1026 // Theory methods should use all of their parameters
        public virtual void JsonLdWriterTests(string testId, JsonLdTestType testType, string inputPath, string contextPath,
                                              string expectedOutputPath, JsonLdErrorCode expectErrorCode, bool useNativeTypes, bool useRdfType, bool ordered, string rdfDirection)
#pragma warning restore xUnit1026 // Theory methods should use all of their parameters
        {
            var nqParser = new NQuadsParser(NQuadsSyntax.Rdf11);
            var input    = new TripleStore();

            nqParser.Load(input, inputPath);
            FixStringLiterals(input);
            var writerOptions = new JsonLdWriterOptions
            {
                UseNativeTypes = useNativeTypes, UseRdfType = useRdfType, Ordered = ordered
            };

            if (rdfDirection != null)
            {
                switch (rdfDirection)
                {
                case "i18n-datatype":
                    writerOptions.RdfDirection = JsonLdRdfDirectionMode.I18NDatatype;
                    break;

                case "compound-literal":
                    writerOptions.RdfDirection = JsonLdRdfDirectionMode.CompoundLiteral;
                    break;

                default:
                    throw new Exception($"Test {testId} specifies an unrecognized value for the rdfDirection option: {rdfDirection}.");
                }
            }
            var jsonLdWriter = new JsonLdWriter(writerOptions);

            switch (testType)
            {
            case JsonLdTestType.PositiveEvaluationTest:
            {
                var actualOutput       = jsonLdWriter.SerializeStore(input);
                var expectedOutputJson = File.ReadAllText(expectedOutputPath);
                var expectedOutput     = JToken.Parse(expectedOutputJson);

                try
                {
                    Assert.True(DeepEquals(expectedOutput, actualOutput, true, true),
                                $"Test failed for input {Path.GetFileName(inputPath)}\nExpected:\n{expectedOutput}\nActual:\n{actualOutput}");
                }
                catch (DeepEqualityFailure ex)
                {
                    Assert.True(false,
                                $"Test failed for input {Path.GetFileName(inputPath)}\nExpected:\n{expectedOutput}\nActual:\n{actualOutput}\nMatch Failured: {ex}");
                }

                break;
            }

            case JsonLdTestType.NegativeEvaluationTest:
            {
                var exception = Assert.Throws <JsonLdProcessorException>(() => jsonLdWriter.SerializeStore(input));
                Assert.Equal(expectErrorCode, exception.ErrorCode);
                break;
            }

            case JsonLdTestType.PositiveSyntaxTest:
                var _ = jsonLdWriter.SerializeStore(input);
                break;

            case JsonLdTestType.NegativeSyntaxTest:
                Assert.ThrowsAny <JsonLdProcessorException>(() => jsonLdWriter.SerializeStore(input));
                break;
            }
        }