DeepEqual | An extensible deep comparison for .NET | Machine Learning library

Wrap the arrays in lists, use distinct(), unwrap them again:

Depending on how you write your tests, you may depend on reflect.DeepEqual() and ignore the linter warning ;
the drawback is : you start depending on the inner structure of the errors you return.

In the testing code I read, and the testing code we write, we use one of the following patterns :

• most of the time, we just compare the error to nil ;
• in some cases our functions return predefined error values, and we test for these specific values :

Here is an extremely rough first pass at such a function (here named diff rather than getChanges):

One thing I notice in your code is that advance() always returns True. The watermark only advances on bundle completion, and I think it's runner-dependent whether a runner will ever complete a bundle if advance ever never returns False. You could try returning False after a bounded amount of time/number of pings.

You could also consider re-writing this as an SDF.

The stubbed implementation by .callFake() is not correct. The bookService.InfoRequest() method accepts a callback parameter, the res is passed to this callback. So you need to provide a stubbed implementation with this callback function and pass your fake error.

E.g.

bookService.js:

It is necessary to create a custom JsonConverterFactory to serialize a Json.NET JToken hierarchy to JSON using System.Text.Json.

Since the question seeks to avoid re-serializing the entire JObject to JSON just to parse it again using System.Text.Json, the following converter descends the token hierarchy recursively writing each individual value out to the Utf8JsonWriter:

The test.assertAtLeastOneEqual() function expects atomic values (item() signature). The only test helper function that can handle elements is test.assertEqualXml(), but that looks for exact matches. I think your best bet is to stringify the permissions. Something like this:

Having a look through the source code of DeepEqual, the library allows for custom comparisons via the IComparison interface. With that, I simulated the models that you require:

I'm going to preserve your implementation as much as possible, even though there might be some improvements there that someone would suggest. I'm primarily taking this question as "how can I tell the TypeScript compiler what getValues() is doing?".

First, we need to represent what comes out when you deeply index into a type T with a dotted keypath K. This is only going to be possible in TypeScript 4.1 and later, since the following implementation relies both on template literal types as implemented in microsoft/TypeScript#40336, and recursive conditional types as implemented in microsoft/TypeScript#40002: